@apia/util 3.0.1 → 3.0.2

package/dist/index.d.ts

@@ -1,69 +1,1866 @@
-export { animate } from './animate/index.js';
-export { default as arrayOrArray } from './array/arrayOrArray.js';
-export { getIndex } from './array/getIndex.js';
-export { decrypt } from './crypto/decrypt.js';
-export { encrypt } from './crypto/encrypt.js';
-export { apiaDateToStandarFormat } from './date/apiaDateToStandarFormat.js';
-export { dateToApiaFormat } from './date/dateToApiaFormat.js';
-export { getDateFormat } from './date/getDateFormat.js';
-export { TDispatchCallback, debugDispatcher, isDebugDispatcherEnabled } from './debug/debugDispatcher.js';
-export { TCallback, TKey, TShortcutBranch, shortcutController } from './debug/shortcutController.js';
-export { DownloadStringAsDocProps, downloadStringAsDoc } from './documents/downloadStringAsDoc.js';
-export { defaultGetNameFromResponse, downloadUrl } from './documents/downloadUrl.js';
-export { openAndReadFile } from './documents/openAndReadFile.js';
-export { autoDisconnectMutationObserver } from './dom/autoDisconnectMutationObserver.js';
-export { findOffsetRelativeToScrollParent } from './dom/findOffsetRelativeToScrollParent.js';
-export { findScrollContainer } from './dom/findScrollContainer.js';
-export { scrollParentIntoElement } from './dom/scrollParentIntoElement.js';
-export { usePanAndZoom } from './dom/usePanAndZoom.js';
-export { customEvents } from './dom/customEvents.js';
-export { cantFocusSelector, focusSelector, getFocusSelector } from './dom/getFocusSelector.js';
-export { getSpecificParent } from './dom/getSpecificParent.js';
-export { isChild } from './dom/isChild.js';
-export { IParameter, Url } from './dom/url.js';
-export { disableChildrenFocus, enableChildrenFocus } from './dom/enableChildrenFocus.js';
-export { decodeHTMLEntities } from './encoding/index.js';
-export { BouncingEmitter, DebounceOptions, ThrottleOptions } from './events/BouncingEmitter.js';
-export { EventEmitter } from './events/EventEmitter.js';
-export { StatefulEmitter, isSetter } from './events/StatefulEmitter.js';
-export { IOnFocusConfiguration, TFocusRetriever, focus, notificationsSelector } from './focus/focusController.js';
-export { globalFocus } from './focus/globalFocus.js';
-export { History, THistoryCount, THistoryStep, THistoryStepChange } from './history/History.js';
-export { useCombinedRefs } from './hooks/useCombinedRefs.js';
-export { useDebouncedCallback } from './hooks/useDebouncedCallback.js';
-export { useLatest } from './hooks/useLatest.js';
-export { useMount } from './hooks/useMount.js';
-export { useUnmount } from './hooks/useUnmount.js';
-export { usePrevious } from './hooks/usePrevious.js';
-export { useStateRef } from './hooks/useStateRef.js';
-export { useSubscription } from './hooks/useSubscription.js';
-export { useUpdateEffect } from './hooks/useUpdateEffect.js';
-export { shallowCompareArrays, shallowEqual, useShallowMemo } from './hooks/useShallowMemo.js';
-export { default as makeImperativeComponent } from './imperative/makeImperativeComponent.js';
-export { default as makeSingleImperativeComponent } from './imperative/makeSingleImperativeComponent.js';
-export { default as useImperativeComponentEvents } from './imperative/useImperativeComponentEvents.js';
-export { default as useImperativeComponentContext } from './imperative/useImperativeIdentifierContext.js';
-export { getLabel } from './labels/getLabel.js';
-export { formatMessage } from './labels/formatMessage.js';
-export { ISetBoundary, addBoundary, noNaN, parseAsSize } from './number/index.js';
-export { getValueByPath } from './objects/getValueByPath.js';
-export { setValueByPath } from './objects/setValueByPath.js';
-export { PropsSelectorUndefinedObject, PropsStore, propsStore } from './propsStore/propsStore.js';
-export { isPropsConfigurationObject, usePropsSelector } from './propsStore/usePropsSelector.js';
-export { TPropsComparator, TPropsConfiguration, TPropsSelector, TUpdateFieldConfiguration } from './propsStore/types.js';
-export { useDomState } from './states/useDomState.js';
-export { useDebouncedState } from './states/useDebouncedState.js';
-export { screenLocker } from './screenLock/screenLocker.js';
-export { BasicStoredElement, StatefulStoreUpdateProps, StatefulStoreUpdater, makeStatefulStore } from './storage/StatefulStore.js';
-export { default as persistentStorage } from './storage/persistentStorage.js';
-export { useLocalStorage } from './storage/useLocalStorage.js';
-export { alignment } from './string/alignment.js';
-export { ucfirst } from './string/ucfirst.js';
-export { toBoolean } from './typeGuards/toBoolean.js';
-export { TApiaAction, TApiaActions, TApiaCellDefinition, TApiaComplexCell, TApiaFunction, TApiaFunctionPageInfo, TApiaLoad, TApiaLoadText, TApiaMessage, TApiaRowDefinition, TApiaSystemMessageObj, TApiaTableFunction, TMessage, TNotificationMessage } from './types/apia/common.js';
-export { TDateFormat } from './types/apia/date.js';
-export { TApiaFieldPropsObj, TApiaFilter, TApiaFilterOption, TApiaFilterValue, TApiaFormButton, TApiaFormElement, TApiaFormElementOption, TApiaLoadForm, TApiaMultiplePossibleValue, TApiaPossibleValue, TApiaRadioPossibleValue, TApiaSelectPossibleValue, TFieldEvent, TFieldScriptEvent, TFieldScriptEvents, TFieldServerEvent, TFieldServerEvents, TFncParams } from './types/apia/forms.js';
-export { TId, TMap, TModify, TRequireOnlyOne } from './types/misc.js';
-export { parseXmlAsync } from './xml/parseXmlAsync.js';
-export { Callback, Map, UnSubscriber } from './events/types.js';
+import * as React from 'react';
+import React__default, { SetStateAction, Dispatch, EffectCallback, MutableRefObject, DependencyList, FC, HTMLAttributes } from 'react';
+import { AxiosResponse } from 'axios';
+
+declare function animate(duration: number, callback: (progress: number) => unknown, onFinish?: () => unknown): () => void;
+
+declare function arrayOrArray<T>(o: T | T[] | undefined): T[];
+
+/**
+ * This function gets an array of elements of any kind and an array of
+ * functions which will be called to test conditions and will return element
+ * whose index equals the matching condition's index
+ *
+ * @param arr An array of elements of any kind
+ * @param conditions An array of conditions, which will be tested in order to determine which index of the array will be returned
+ * @param defaultIndex The return value in case that no condition matches
+ * @returns An element of the array if any of the conditions matches or the defaultIndex otherwise.
+ */
+declare function getIndex<T = unknown>(arr: T[], conditions: (boolean | (() => boolean))[], defaultIndex?: number): T;
+
+declare const decrypt: (salt: string, iv: string, passPhrase: string, cipherText: string, keySize: number, iterationCount: number) => Promise<string>;
+
+declare const encrypt: (salt: string, iv: string, passPhrase: string, plainText: string, keySize: number, iterationCount: number) => Promise<string>;
+
+declare function apiaDateToStandarFormat(date: string): string;
+
+declare function dateToApiaFormat(date: string | Date): string;
+
+type TDateFormat = 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'YYYY/MM/DD';
+
+declare global {
+    interface Window {
+        DATE_FORMAT: string;
+    }
+}
+declare const getDateFormat: () => TDateFormat;
+
+declare global {
+    const WP_DEVELOP_MODE: boolean;
+}
+/**
+ * Indica si el debugDispatcher fue activado, lo que en muchos casos indica que
+ * estamos en ambiente de desarrollo
+ */
+declare function isDebugDispatcherEnabled(): boolean;
+type TWindowDDispatch = (action: string, ...parameters: unknown[]) => void;
+type TDispatchCallback = (parameters: unknown[]) => unknown;
+interface IStoredCallback {
+    (parameters: unknown[]): unknown;
+    help: () => void;
+}
+declare const debugDispatcher: {
+    callbacks: Record<string, IStoredCallback[]>;
+    actions: Record<string, () => void>;
+    on(action: string, cb: TDispatchCallback, help: string | React__default.ReactNode, onlyDevelop?: boolean): () => void;
+    off(action: string, cb: TDispatchCallback): void;
+    emit: TWindowDDispatch;
+};
+declare global {
+    interface Window {
+        adt: typeof debugDispatcher;
+        dd: typeof debugDispatcher & Record<string, () => unknown>;
+    }
+}
+
+type TCallback = (ev: KeyboardEvent) => unknown;
+type TKey = {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+};
+type TShortcutBranch = {
+    key: TKey;
+    children: TShortcutBranch[];
+    callbacks: TCallback[];
+    fireEvenFromInputs?: boolean;
+};
+declare const shortcutController: {
+    history: TKey[];
+    candidates: TShortcutBranch[];
+    shortcuts: TShortcutBranch;
+    shortcutsStrings: string[];
+    categories: {
+        dev: string[];
+    };
+    parseKeyToString(key: string | TKey): string;
+    parseKey(keyString: string): TKey;
+    /**
+     * Para setear un shorcut se puede pasar un string representativo con la
+     * forma:
+     *
+     * **alt**?&**ctrl**?&**shift**?&**(\w)**
+     *
+     * Donde: alt? ctrl? shift? implica que cualquiera de esas palabras pueden o
+     * no aparecer y (\w) es una letra, símbolo o número.
+     *
+     * Puede aparecer cualquier tecla de control o no, pero el símbolo o letra
+     * debe aparecer.
+     *
+     * @param category
+     * Agrega un prefijo de teclas que se deben presionar antes del shortcut para
+     * que funcione, de forma que por ejemplo, todos los shortcuts de la categoría
+     * dev serán ejecutados solamente si antes se presionó shift&D
+     *
+     * @example
+     *
+      shortcutController.on(['shift&A', 'b', 'ctrl&c', 'alt&d'], (ev) => {
+        ev.preventDefault();
+        console.log('Abctrl+cd'),
+      }); // Este shortcut se ejecuta en desarrollo y producción
+  
+      shortcutController.on('unshortcut'.split(''), (ev) => {
+        ev.preventDefault();
+        console.log('Abctrl+cd'),
+      }, 'dev'); // Este shortcut solo se ejecuta en desarrollo
+     */
+    on(keys: (string | TKey)[], callback: TCallback, category?: keyof typeof this.categories, fireEvenFromInputs?: boolean): void;
+};
+
+type DownloadStringAsDocProps = {
+    fileName?: string;
+    blobProps?: BlobPropertyBag;
+};
+declare function downloadStringAsDoc(content: string, options?: DownloadStringAsDocProps): Promise<void>;
+
+declare function defaultGetNameFromResponse(blob: AxiosResponse): string;
+/**
+ * This function gets an URL and a file name and performs a file download.
+ *
+ * @param url The url to fetch
+ * @param getNameFromResponse The name will be given by the 'content-disposition' prop in the headers
+ */
+declare function downloadUrl(url: string, getNameFromResponse?: (blob: AxiosResponse) => string): Promise<void>;
+/**
+ * This function gets an URL and a file name and performs a file download.
+ *
+ * @param url The url to fetch
+ * @param fileName The name the file will have as default in the save dialog
+ */
+declare function downloadUrl(url: string, fileName: string): Promise<void>;
+
+declare function openAndReadFile(): Promise<string | ArrayBuffer | null>;
+
+interface IAutoDisconnectMutationObserverConf {
+    /** Por defecto es true */
+    runCallbackOnInit?: boolean;
+    /** Por defecto es 100 (ms) */
+    timeout?: number;
+}
+/**
+ * Crea un observer que va a desconectarse automáticamente luego de que pase
+ * una determinada cantidad de tiempo sin actividad en el elemento.
+ *
+ * Se usa especialmente para esperar que un componente termine de renderizar y
+ * aplicar cálculos a nivel de layout sobre él.
+ */
+declare function autoDisconnectMutationObserver(element: HTMLElement, callback: () => unknown, conf?: IAutoDisconnectMutationObserverConf): () => void;
+
+/**
+ * Esta función calcula el offset que existe entre un elemento y su padre más inmediato que tenga scroll visible
+ */
+declare function findOffsetRelativeToScrollParent(element: HTMLElement, which?: 'Left' | 'Top'): number;
+
+/**
+ * Encuentra el primer elemento padre del elemento provisto que tenga scroll
+ * activo.
+ */
+declare function findScrollContainer(el: HTMLElement): HTMLElement | null;
+
+/**
+ * Busca el padre con scroll visible y establece su scrollTop de acuerdo al offset del elemento pasado como argumento, de modo que éste aparezca visible dentro del padre mencionado.
+ *
+ * @param fixedOffsetTop Establece un mínimo de distancia que debe mantener con el borde superior del contenedor con scroll. Se usa para compensar en las situaciones donde existen cabezales fijos.
+ */
+declare function scrollParentIntoElement(element: HTMLElement, fixedOffsetTop?: number, tries?: number, timeout?: number, scrollId?: string | undefined): void;
+
+declare function usePanAndZoom<ContainerType extends HTMLElement = HTMLElement, ChildType extends HTMLElement | SVGElement = HTMLElement>(effectiveMargin?: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}, blockZoom?: boolean): {
+    boxRef: React__default.RefObject<ContainerType>;
+    elementRef: React__default.RefObject<ChildType>;
+};
+
+/**
+ * Existen algunos eventos que se disparan en la
+ * aplicación con la finalidad de desencadenar
+ * un comportamiento específico. Por ello se declaran
+ * las siguientes constantes.
+ */
+declare const customEvents: {
+    /**
+     * Indica que un elemento necesita recibir el foco,
+     * de esta forma, elementos que no se están mostrando
+     * en pantalla (por display:none por ejemplo), pueden
+     * indicar a sus ancestros que deben expandirse.
+     */
+    focus: string;
+    /**
+     * Indica que debe cambiarse el título del modal
+     */
+    iframeModalChangeTitle: string;
+    /**
+     * Indica que un iframe modal debe cerrarse
+     */
+    iframeModalClose: string;
+    /**
+     * Indica que un iframe modal debe cerrarse
+     */
+    iframeModalNotify: string;
+    /**
+     * Indica que un modal debe cerrarse
+     */
+    modalClose: string;
+    /**
+     * Indica que el panel contenedor debe cerrarse porque
+     * está vacío
+     */
+    hidePanel: string;
+    showPanel: string;
+};
+
+/**
+ * Este selector pretende abarcar todos modificadores que en caso de estar
+ * presentes hacen que un elemento no sea focusable
+ */
+declare const cantFocusSelector: string;
+/**
+ * Este selector pretende abarcar todos los elementos que sean focusables
+ */
+declare const focusSelector: string;
+/**
+ * Genera un selector que permitirá seleccionar
+ * todos los elementos candidatos a recibir foco,
+ * que no cumplan con la condición not pasada
+ * como parámetro.
+ *
+ * @param not Un selector not css, indicando cuáles
+ * condiciones deben evitar el foco en un elemento.
+ *
+ * @returns Una cadena que representa un selector
+ * css.
+ */
+declare function getFocusSelector(not?: string): string;
+
+/**
+ * Searches for a specific parent of a element,
+ * using a callback function as the source of
+ * truth in order to determine which is the correct
+ * parent.
+ *
+ * @param element The element where the process
+ * starts.
+ *
+ * @param checkParent A callback that will be
+ * called for each of the ancestors of the element
+ * until the desired parent is found.
+ * This function should return **true when found**
+ * the desired parend was found, **null to cancel**
+ * the search or **false to continue searching**.
+ *
+ * @returns The specific parent or null in case
+ * the root parent element is raised.
+ */
+declare function getSpecificParent(element: HTMLElement | null, checkParent: (parent: HTMLElement) => boolean | null): HTMLElement | null;
+
+/**
+ * Permite iterar desde un elemento hacia arriba en el
+ * DOM, utilizando una función de comparación para
+ * determinar si el elemento actual es el que estamos
+ * buscando.
+ *
+ * Si la función checkParent devuelve true, isChild
+ * devuelve true.
+ */
+declare function isChild(element: HTMLElement | null, checkParent: (parent: HTMLElement) => boolean | null): boolean;
+
+interface IParameter {
+    name: string;
+    value: unknown;
+    allowMultiple?: boolean;
+}
+declare class Url {
+    #private;
+    defaultAllowMultiple: boolean;
+    base: string;
+    constructor(baseUrl: string, defaultAllowMultiple?: boolean);
+    addParameter(name: string, value: unknown, allowMultiple?: boolean): void;
+    addParameters(parameters: IParameter[]): void;
+    getParameter(name: string): string | string[];
+    toString(): string;
+}
+
+/**
+ * Deshabilita la posibilidad de hacer foco en
+ * todos los descendientes de parent. Es
+ * especialmente útli cuando se ocultan elementos
+ * del DOM sin quitarlos, cuando por accesibilidad
+ * es importante que el foco no alcance a dichos
+ * métodos.
+ */
+declare function disableChildrenFocus(parent: HTMLElement): void;
+/**
+ * Restaura el foco de los hijos de parent a los
+ * que previamente se les había quitado el foco
+ * con disableChildrenFocus.
+ */
+declare function enableChildrenFocus(parent: HTMLElement): void;
+
+/**
+ * Toma una cadena de texto que puede tener caracteres de escape de HTML (por
+ * ejemplo &aacute;) y devuelve su correspondiente en texto plano.
+ */
+declare const decodeHTMLEntities: (str: string) => string | null;
+
+/**
+ * @public
+ *
+ * A basic Record
+ * */
+type Map = Record<string, unknown>;
+/**
+ * @public
+ *
+ * This is the callback provided by the listener any time it wants to subscribe to an event.
+ */
+type Callback<Events extends Map, K extends keyof Events = keyof Events> = (data: Events[K]) => unknown;
+/**
+ * @internal
+ *
+ * This is the emitter's callbacks storage
+ */
+type Callbacks<Events extends Map> = {
+    [K in keyof Events]: Callback<Events, K>[];
+};
+/**
+ * @public
+ *
+ * A method that unsubscribes the recently made subscription.
+ */
+type UnSubscriber = () => void;
+
+/**
+ * @public
+ *
+ * The `EventEmitter` class is a generic utility for handling events. It allows subscribing to and emitting events.
+ * This class is generic and works with a `Map` where keys are event names and values are the types associated with those events.
+ *
+ * @typeParam  Events - An extension of `Map` where the key is the event name and the value is the type of data associated with that event.
+ */
+declare class EventEmitter<Events extends Map> {
+    protected callbacks: Record<'on' | 'once', Callbacks<Events>>;
+    protected enabled: boolean;
+    protected debugMode: boolean;
+    debug(enable?: boolean): void;
+    /**
+     * Emits an event with the given data. Any listeners subscribed to this event will be invoked with the passed data.
+     *
+     * @param event - The event name to emit.
+     * @param data - The data associated with the event. Its type is dependent on the event name.
+     */
+    emit<K extends keyof Events>(event: K, data: Events[K]): void;
+    /**
+     * Reflects the current emitter state. A disabled state indicates that the emitter wont call listeners until its functionality gets enabled again.
+     */
+    get isEnabled(): boolean;
+    off<K extends keyof Events>(event: K, cb: Callback<Events, K>): void;
+    /**
+     * Subscribes a callback function to an event. The callback is invoked each time the event is emitted.
+     *
+     * @param event - The event name to listen to.
+     * @param cb - The callback function to be invoked when the event is emitted.
+     * @returns A function to unsubscribe the event listener.
+     */
+    on<K extends keyof Events>(event: K, cb: Callback<Events, K>): UnSubscriber;
+    /**
+     * Subscribes a callback function to an event for a single occurrence. After the event is emitted once, the listener is automatically removed.
+     *
+     * @param event - The event name to listen to for a single occurrence.
+     * @param cb - The callback function to be invoked when the event is emitted.
+     * @returns A function to unsubscribe the event listener.
+     */
+    once<K extends keyof Events>(event: K, cb: Callback<Events, K>): UnSubscriber;
+}
+
+type Setter<T> = (prevState: T) => T;
+type Selector<State, Selected> = (state: State) => Selected;
+type Comparator<Selected> = (newSelection: Selected, previousSelection: Selected) => boolean;
+declare function isSetter<T>(data: SetStateAction<T>): data is Setter<T>;
+/**
+ * @private
+ */
+type EmitterState<Events extends Map> = {
+    [K in keyof Events]: Events[K];
+};
+/**
+ * Extends EventEmitter to manage and emit events with state persistence.
+ * This class allows emitting and listening to typed events while also keeping
+ * a state that can be accessed synchronously for each event.
+ *
+ * @param initialState - If given will be passed to subscriptions
+ *
+ * @template Events - A mapping of event names to their associated data types.
+ * @extends EventEmitter<Events>
+ */
+declare class StatefulEmitter<Events extends Map> extends EventEmitter<Events> {
+    protected state: EmitterState<Events>;
+    constructor(initialState?: Partial<Events>);
+    emit<K extends keyof Events>(event: K, data: Events[K]): void;
+    on<K extends keyof Events>(event: K, cb: Callback<Events, K>): UnSubscriber;
+    once<K extends keyof Events>(event: K, cb: Callback<Events, K>): UnSubscriber;
+    /**
+     * Retrieves the stored state for a given event
+     */
+    getState<K extends keyof Events>(event: K): EmitterState<Events>[K];
+    /**
+     * Just an alias for emit, with the advantage that can be called with a callback as second parameter in which case behaves exactly as react's setState.
+     */
+    setState<K extends keyof Events>(event: K, data: SetStateAction<Events[K]>): void;
+    /**
+     * Allows to consume an event stream as a real time updated state
+     */
+    useState: <K extends keyof Events>(event: K) => EmitterState<Events>[K];
+    useStateSelector: <K extends keyof Events, Selected>(event: K, selector: Selector<Events[K], Selected>, comparator?: Comparator<Selected>) => Selected;
+}
+
+type BouncingMap<Events extends Map> = {
+    [K in keyof Events]: number;
+};
+declare const NullObject: unique symbol;
+type ThrottlingMap<Events extends Map> = {
+    [K in keyof Events]: Events[K] | typeof NullObject;
+};
+type ThrottlingMarkers<Events extends Map> = {
+    [K in keyof Events]: boolean;
+};
+type DebounceOptions = Partial<{
+    timing: number;
+}>;
+type ThrottleOptions = Partial<{
+    emitOnStart?: boolean;
+    timing: number;
+}>;
+/**
+ * @public
+ *
+ * The BouncingEmitter class is an extension of EventEmitter which adds debouncing and throttling functionality.
+ *
+ * @typeParam — Events - An extension of Map where the key is the event name and the value is the type of data associated with that event.
+ */
+declare class BouncingEmitter<Events extends Map> extends StatefulEmitter<Events> {
+    protected bouncingTimeouts: BouncingMap<Events>;
+    protected defaultTiming: number;
+    /**
+     * Debounces a event emit with until there is no call to the emit methods by (timing)ms. Take the following event throttling, where each E is a call to this method and each character represents 20ms:
+     *
+     * E_E_E_E_E_E_E_E_E
+     *
+     * If timing is configured to 100ms, which is the default, the emission will occur as follows:
+     *
+     * _____________________E
+     */
+    debounce<K extends keyof Events>(event: K, data: Events[K], configuration?: DebounceOptions): void;
+    /**
+     * Throttles a event emit with the warranty that the data will be emitted at most every (timing)ms. Take the following event throttling, where each E is a call to this method and each character represents 20ms:
+     *
+     * E_E_E_E_E_E_E_E_E
+     *
+     * If timing is configured to 100ms, which is the default, the emission will occur as follows:
+     *
+     * ____E____E____E______E
+     *
+     * @param configuration.emitOnStart - Emits an event on the first call to throttle when no pending throttle is stored. **If emitOnStart is true and an only call to throttle is made, it will emit an only event.**
+     */
+    protected throttleData: ThrottlingMap<Events>;
+    protected throttleEmittedOnInit: ThrottlingMarkers<Events>;
+    throttle<K extends keyof Events>(event: K, data: Events[K], configuration?: ThrottleOptions): void;
+    /**
+     * This method is a mix between setState and debounce
+     */
+    setStateDebounced<K extends keyof Events>(event: K, data: SetStateAction<Events[K]>, configuration?: DebounceOptions): void;
+    /**
+     * This method is a mix between setState and throttle
+     */
+    setStateThrottled<K extends keyof Events>(event: K, data: SetStateAction<Events[K]>, configuration?: ThrottleOptions): void;
+}
+
+interface TFncParams {
+    type: 'V' | 'P' | 'E';
+    value?: string;
+    attId?: number;
+}
+type TApiaFormButton = {
+    onclick: string;
+    text: string;
+    id: string;
+    type: string;
+};
+interface TApiaSelectPossibleValue {
+    value: string | number;
+    label: string;
+    selected?: boolean;
+}
+interface TApiaMultiplePossibleValue {
+    value: string | number;
+    label: string;
+    selected?: boolean;
+}
+interface TApiaRadioPossibleValue {
+    value: string | number;
+    label: string;
+    selected?: boolean;
+}
+type TApiaPossibleValue = TApiaRadioPossibleValue & TApiaMultiplePossibleValue & TApiaSelectPossibleValue;
+type TFieldEvent = 'onLoad' | 'onReload' | 'onSubmit' | 'onChange' | 'onModalReturn' | 'onClick' | 'onPopulate' | 'populate' | 'gridAdd' | 'gridSort' | 'gridSortUp' | 'gridSortDown' | 'gridDelete' | 'gridColumnSelect' | 'JSApiaUpdate' | 'onSubmit';
+interface TFieldScriptEvent {
+    fncName: string;
+    evtName: Readonly<TFieldEvent>;
+    evtId: number | string;
+    fncParams: TFncParams[];
+}
+type TFieldScriptEvents = TFieldScriptEvent[];
+interface TFieldServerEvent {
+    evtId: number;
+    evtName: Readonly<TFieldEvent>;
+    isAjax: boolean;
+}
+type TFieldServerEvents = TFieldServerEvent[];
+interface TApiaFieldPropsObj {
+    alignment?: string;
+    alt?: string;
+    bold?: string;
+    checked?: boolean;
+    colspan?: number;
+    cssClass?: string;
+    disabled?: boolean;
+    docType?: string;
+    dontBreakRadio?: boolean;
+    fontColor?: string;
+    gridHeight?: number;
+    gridColTitle?: string;
+    gridTitle?: string;
+    height?: string;
+    hideAddButton?: boolean;
+    hideDelButton?: boolean;
+    hideDocMetadata?: boolean;
+    hideDocPermissions?: boolean;
+    hideGridButtons?: boolean;
+    hideIncludeButton?: boolean;
+    hideOrderButton?: boolean;
+    hideSignButtons?: boolean;
+    pagedGridSize?: number;
+    paged?: boolean;
+    includeFirstRow?: boolean;
+    imageUrl?: string;
+    inputAsText?: boolean;
+    isActuallyReadonly?: boolean;
+    multiselect?: boolean;
+    name?: string;
+    noPrint?: boolean;
+    readonly?: boolean;
+    readOnly?: boolean;
+    regExpMessage?: string;
+    reqSign?: boolean;
+    reqTrad?: boolean;
+    required?: boolean;
+    rowspan?: number;
+    selParent?: boolean;
+    size?: string;
+    storeMdlQryResult?: boolean;
+    tooltip?: string;
+    tooltipHelp?: boolean;
+    transient?: boolean;
+    underlined?: boolean;
+    url?: string;
+    value?: unknown;
+    updateValueWithoutSynchronize?: unknown;
+    valueColor?: string;
+    visibilityHidden?: boolean;
+    possibleValue?: TApiaSelectPossibleValue[] | TApiaSelectPossibleValue | TApiaRadioPossibleValue[] | TApiaMultiplePossibleValue[] | TApiaMultiplePossibleValue;
+    leafIcon?: string;
+    parentIcon?: string;
+    props?: string;
+    id?: string;
+    noLock?: boolean;
+    noErase?: boolean;
+    noModify?: boolean;
+    noDownload?: boolean;
+    allowEdition?: boolean;
+    hideDocDownload?: boolean;
+    qryId?: string;
+    startIndex?: number;
+    curPage?: number;
+    pages?: number;
+    rowCount?: number;
+    maxRecords?: number;
+    colWidth?: string;
+    gridForm?: string;
+    documentMonitorCus?: number;
+    fileCollapseFldStrc?: boolean;
+    fileCollapseMetadata?: boolean;
+    fileCollapsePermission?: boolean;
+    fileDefFolder?: number;
+    fileDntShwDocMdlOnDrop?: boolean;
+    fileExpDate?: boolean;
+    fileNoAllwDnD?: boolean;
+    fileNotShowDocMon?: boolean;
+    fileShowDesc?: boolean;
+    fileShwFoldTreeBtn?: boolean;
+    fileShwFoldTreeStr?: boolean;
+    oneClickUpload?: boolean;
+    fieldId?: string;
+    hasFinishedLoading?: boolean;
+}
+type TApiaFormElementOption = {
+    content: string;
+    value: string;
+};
+type TApiaFormElement = {
+    adtInfo?: string;
+    class: string;
+    disabled: boolean;
+    html: boolean;
+    id: string;
+    isADate: boolean;
+    mandatory: boolean;
+    maxlength?: string;
+    modalFunction?: string;
+    name: string;
+    normalWhiteSpace: boolean;
+    onChange: string;
+    options: {
+        option: TApiaFormElementOption | TApiaFormElementOption[];
+    };
+    readonly: boolean;
+    regExp?: string;
+    regExpMessage?: string;
+    selected: boolean;
+    size: string;
+    text: string;
+    title: string;
+    type: string;
+    value: string;
+    valueAsAttribute: boolean;
+};
+type TApiaLoadForm = {
+    form: {
+        closeOnSubmit: boolean;
+        multiPart: boolean;
+        ajaxNewPanel: boolean;
+        showErrors: boolean;
+        doEscape: boolean;
+        action: string;
+        onLoad: string;
+        ajaxsubmit: boolean;
+        closeAll: boolean;
+        title: string;
+        autoExpand: boolean;
+        titleClass: string;
+        addClass: string;
+        elements?: {
+            label: string;
+            element: TApiaFormElement | TApiaFormElement[];
+        };
+        buttons?: {
+            button: TApiaFormButton | TApiaFormButton[];
+        };
+    };
+};
+type TApiaFilterValue = string | number;
+type TApiaFilterOption = {
+    label: string;
+    value: TApiaFilterValue;
+    selected?: boolean;
+    id?: string;
+    name?: string;
+};
+type TApiaFilter = {
+    asAdditional?: boolean;
+    column?: string;
+    currentValue: TApiaFilterValue;
+    deleteFiltersTimestamp?: number;
+    error?: string;
+    id: string | number;
+    isMeta?: boolean;
+    placeholder?: string;
+    runAutomatically?: boolean;
+    title?: string;
+    toolTip?: string;
+    detectOnChange?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    sortCombo?: boolean;
+    /**
+     * Con esta propiedad se permite agupar los filtros para mostrarlos en un
+     * panel especifico.
+     */
+    group?: string;
+    options?: TApiaFilterOption[];
+    type?: 'date' | 'D' | 'S' | 'number' | 'N' | 'apiaNumber';
+    hide?: boolean;
+    hideToFilter?: boolean;
+    filterToId?: string;
+    filterToValue?: TApiaFilterValue;
+    isRange?: boolean;
+};
+
+interface TApiaAction {
+    toDo?: string;
+    param: string | string[];
+}
+interface TApiaActions {
+    action: TApiaAction | TApiaAction[];
+}
+interface TApiaMessage {
+    text: string;
+    label?: string;
+}
+type TApiaComplexCell = {
+    label: string;
+    classToAdd?: string;
+    isHTML?: boolean;
+    docName?: string;
+    forceTitle?: string;
+    [key: string]: unknown;
+};
+type TApiaCellDefinition = TApiaComplexCell | string;
+type TApiaRowDefinition = {
+    'data-selected'?: boolean;
+    selected?: boolean;
+    dblclic: boolean;
+    id: string;
+    classToAdd?: string;
+    rowSeparator?: boolean;
+    suspended?: boolean;
+    unselectableTR?: boolean;
+    headName?: string;
+    isLocked?: boolean;
+    cell: TApiaCellDefinition | TApiaCellDefinition[];
+    boldType?: boolean;
+    'expired-doc': true;
+};
+type TApiaFunctionPageInfo = {
+    amount: string;
+    currentPage: string;
+    hasMore: boolean;
+    pageCount: string;
+    prefix: string;
+    reachedMax: boolean;
+    selectOnlyOne: boolean;
+    totalRecords: string;
+    orderType: 'desc' | '';
+    orderCol: number;
+};
+type TApiaSystemMessageObj<Structure = Record<string, unknown>> = Structure & {
+    onClose?: string;
+    sysMessages?: {
+        message: TApiaMessage | TApiaMessage[];
+    };
+    sysExceptions?: {
+        exception: TApiaMessage | TApiaMessage[];
+    };
+    exceptions?: {
+        exception: TApiaMessage | TApiaMessage[];
+    };
+    actions?: TApiaActions;
+    code?: unknown;
+    load?: Structure;
+};
+type TApiaTableFunction = {
+    result: {
+        pageInfo: TApiaFunctionPageInfo;
+        table?: {
+            row: TApiaRowDefinition | TApiaRowDefinition[];
+        };
+    };
+};
+type TApiaFunction<T = TApiaTableFunction, HasMessages = true> = HasMessages extends true ? {
+    function: {
+        dropLastMessage?: boolean;
+        name: string;
+        messages: T;
+    };
+} : {
+    function: {
+        name: string;
+    } & T;
+};
+type TApiaLoadText = {
+    text: {
+        closeAll: boolean;
+        title: string;
+        addClass: string;
+        content: string;
+    };
+};
+type TApiaLoad<T extends Record<string, unknown> = TApiaLoadForm> = {
+    canClose: boolean;
+    type: string;
+} & T;
+interface TMessage {
+    text: string;
+    content?: string;
+    title?: string;
+    type?: string;
+}
+interface TNotificationMessage {
+    onClose?: string;
+    sysMessages?: {
+        message: TMessage | TMessage[];
+    };
+    sysExceptions?: {
+        exception: TMessage | TMessage[];
+    };
+    exceptions?: {
+        exception: TMessage | TMessage[];
+    };
+}
+
+type TId = string | number;
+type TModify<T, R> = Omit<T, keyof R> & R;
+type TMap$1<T> = Record<string | number, T>;
+type TRequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+
+interface IFocusProps {
+    modalsContainerRetriever?: () => HTMLElement;
+    notificationsContainerRetriever?: () => HTMLElement;
+}
+interface IOnFocusConfiguration {
+    /**
+     * El controlador emite un evento custom cuando se realiza foco, con la
+     * intención de que los elementos colapsables se abran automáticamente. Si
+     * este parámetro es pasado con false, se evita ese comportamiento.
+     */
+    dispatchCustomEvent?: boolean;
+    /**
+     * Cuando la pantalla está bloqueada con el spinner, el controlador no
+     * intentará hacer foco, a menos que este parámetro se pase en true.
+     */
+    focusEvenWhenScreenLocked?: boolean;
+    scrollIntoViewOptions?: ScrollIntoViewOptions;
+}
+declare const notificationsSelector = ".notification";
+/**
+ * Al método focus.on se le puede pasar o bien un HTMLElement o bien una
+ * función que implemente esta interfaz. Cuando se pasa una función, la misma
+ * será invocada cada vez que se vaya a intentar una acción de foco.
+ *
+ * Si la función devuelve un elemento HTML, se intentará hacer foco sobre éste.
+ *
+ * Si la función devuelve null, ese intento será tomado como nulo y se volverá
+ * a intentar luego del tiempo determinado.
+ *
+ * Si la función devuelve false, será eliminada de la cola de foco, lo que
+ * significa que ya no se intentará hacer foco sobre este elemento. En cambio,
+ * se continuará con los demás elementos de la cola o en caso de no haber
+ * ninguno, con el último elemento que tuvo foco y aún esté presente en el
+ * documento.
+ */
+type TFocusRetriever = (isLastTry: boolean) => HTMLElement | null | false;
+interface IFocusQueryElement {
+    element: HTMLElement | TFocusRetriever;
+    configuration?: IOnFocusConfiguration;
+}
+declare global {
+    interface Window {
+        focusStatus: Record<string, unknown>;
+    }
+}
+interface IFocusCheck {
+    currentInstruction: number;
+}
+declare const focus: {
+    "__#5@#root": HTMLElement;
+    "__#5@#props": IFocusProps | undefined;
+    afterNotificationFocus: IFocusQueryElement | undefined;
+    "__#5@#actualFocusQuery": IFocusQueryElement[];
+    "__#5@#currentInstruction": number;
+    "__#5@#focusDelay": number;
+    "__#5@#focusRetries": number;
+    "__#5@#focusTimeout": number;
+    "__#5@#isIntervalRunning": boolean;
+    "__#5@#focusQuery": IFocusQueryElement[];
+    "__#5@#checkInstruction"(focusCheck: IFocusCheck): boolean;
+    "__#5@#doFocus"(HTMLElement: HTMLElement | TFocusRetriever, focusCheck: IFocusCheck, isLastTry: boolean, configuration?: IOnFocusConfiguration): Promise<false | HTMLElement | null>;
+    "__#5@#resetInterval"(): void;
+    "__#5@#runFocusInterval"(focusElement?: IFocusQueryElement, internalCall?: boolean): Promise<false | HTMLElement>;
+    /**
+     * Da la instrucción de colocar el foco en el elemento provisto como
+     * parámetro una vez que todas las notificaciones se hayan cerrado. En caso
+     * de no existir notificaciones abiertas, hace foco en el elemento
+     * directamente.
+     */
+    afterNotifications(element: HTMLElement | TFocusRetriever, configuration?: IOnFocusConfiguration): void;
+    /**
+     * Da la instrucción de colocar el foco en el elemento provisto como
+     * parámetro luego de recargar la página.
+     *
+     * Los parámetros pasados serán ordenados en orden de importancia priorizando
+     * en el siguiente orden:
+     * - id
+     * - name
+     * - className
+     * - selector
+     */
+    afterReload({ className, id, name, selector, }: TRequireOnlyOne<{
+        className: string;
+        id: string;
+        name: string;
+        selector: string;
+    }>): void;
+    /**
+     * Da la instrucción de colocar el foco el elemento pasado como parámetro.
+     * Se puede pasar también una función que devuelva HTMLElement | false |
+     * null.
+     *
+     * El segundo parámetro del método on es un objeto de tipo
+     * ScrollIntoViewOptions, que permite modificar el comportamiento del scroll
+     * a en el elemento.
+     *
+     * @see TFocusRetriever para más detalles sobre la función como parámetro.
+     */
+    on(element: HTMLElement | TFocusRetriever, configuration?: IOnFocusConfiguration): Promise<false | HTMLElement>;
+    focusOnReload: string | null;
+    restore(): void;
+    init(): void;
+};
+
+/**
+ * The GlobalFocus helper keeps a list of the last focused elements and allows
+ * to retrieve the last focused element which matches against a query selector.
+ */
+declare const globalFocus: {
+    focused: (HTMLElement | TFocusRetriever)[];
+    "__#2@#onFocusCallbacks": (() => unknown)[];
+    offFocus(cb: () => unknown): void;
+    onFocus(cb: () => unknown): () => void;
+    inDocument(el: HTMLElement | TFocusRetriever): boolean;
+    focus: HTMLElement | TFocusRetriever;
+    readonly list: (HTMLElement | TFocusRetriever)[];
+    /**
+     * @param querySelector A query selector against which the element should match
+     * @returns The last HTMLElement if no querySelector argument provided or else, the last which matches
+     * against that query selector.
+     * */
+    last(querySelector?: string, omit?: number): HTMLElement | TFocusRetriever | null;
+};
+
+type THistoryCount = {
+    currentStep: number;
+    stepCount: number;
+};
+type THistoryStep<T> = {
+    content: T;
+} & THistoryCount;
+type THistoryStepChange<T> = THistoryCount & THistoryStep<T> & {
+    fromPush?: boolean;
+    hasPrevious: boolean;
+    hasNext: boolean;
+};
+type THistoryConfiguration = {
+    maxLength: number;
+};
+/**
+ * # Cómo usar el historial
+ *
+ * Es muy sencillo: se instancia con un callback que recibirá un método push
+ * cada vez que una ventana se cierre. En esos momentos, el usuario del History
+ * puede hacer push al estado.
+ *
+ * ## La mecánica
+ *
+ * - Instancio la clase y recibo el método push
+ * - Cuando se realizan cambios significativos, llamo al método openWindow
+ * - El método openWindow da una ventana de 350ms antes de llamar al callback
+ * - Si durante esa ventana se vuelve a llamar a openWindow, la ventana se
+ * resetea
+ * - Si al llamar al callback, se hace push al estado, ese estado es propagado
+ * mediante el hook y mediante el evento on('stepChange')
+ *
+ * ## Cómo escuchar cambios
+ *
+ * ```ts
+ * this.history.on('stepChange', (data) => {
+     if (!data.fromPush) this.update(data.content);
+  });
+  ```
+ *
+ * ## Back y forward
+ *
+ * El back y forward son dos métodos del history que hacen un stepChange y
+ * emiten a través de on('stepChange') y el hook
+ */
+declare class History<T> extends EventEmitter<{
+    stepChange: THistoryStepChange<T>;
+}> {
+    private configuration;
+    private autocloseTimeout;
+    private currentStep;
+    private content;
+    private emitting;
+    protected enabled: boolean;
+    private _isOpen;
+    private timeoutMs;
+    constructor(onCloseWindow: (push: (newState: T) => void) => unknown, configuration?: THistoryConfiguration);
+    private closeWindow;
+    private getEvent;
+    private onCloseWindow;
+    private push;
+    private shoutStepChange;
+    hooks: {
+        useCountChange: (onChange: (ev: THistoryStepChange<T>) => unknown) => void;
+    };
+    back: () => void;
+    disable: () => void;
+    emit<K extends 'stepChange'>(eventName: K, params?: THistoryStepChange<T>): void;
+    enable: () => void;
+    forward: () => void;
+    get isOpen(): boolean;
+    openWindow: () => void;
+    reset: () => void;
+    updateConfig: (newConfiguration: Partial<THistoryConfiguration>) => void;
+    useStep: () => Pick<THistoryStepChange<T>, "hasNext" | "hasPrevious" | "currentStep">;
+}
+
+/**
+ * Permite reasignar múltiples referencias desde un mismo componente.
+ *
+ * @example
+ *
+ * const ref1 = useRef(null)
+ * const ref2 = useRef(null)
+ *
+ * const assignRefs = useMultipleRefs(ref1, ref2);
+ *
+ * return <Box ref={assignRefs} ...
+ */
+declare function useCombinedRefs<RefType = HTMLInputElement>(...refs: (React.ForwardedRef<unknown> | undefined)[]): React.Dispatch<React.SetStateAction<RefType | undefined>>;
+
+declare const useDebouncedCallback: <Params extends any[]>(callback: (...params: Params) => unknown, { runWhenTriggered, timeout }?: {
+    runWhenTriggered: boolean;
+    timeout: number;
+}) => (...params: Params) => void;
+
+/**
+ * Este hook permite mantener un estado interno en un componente, al mismo tiempo que se escucha el estado externo a través de las props, permitiendo la edición del valor en forma interna, a la vez que se permite su definición desde los padres del componente.
+ *
+ * Es útil especialmente en campos de tipo input en los cuales es deseable permitir al usuario escribir libremente, y luego de validada la entrada, establecer un valor diferente para mostrar.
+ */
+declare function useIntermediateValue<T>(currentValue: T): [T, Dispatch<SetStateAction<T>>];
+
+/**
+ * Devuelve una referencia que mantiene siempre el último valor del elemento
+ * pasado, es especialmente útil para acceder a valores del componente desde
+ * dentro de efectos.
+ *
+ * *Investigar qué es 'react stale state'*
+ */
+declare function useLatest<T>(value: T): React.MutableRefObject<T>;
+
+declare function useMount(effect: EffectCallback): void;
+
+declare function useUnmount(unmountCallback: () => void): void;
+
+declare function usePrevious<T>(value: T): React.MutableRefObject<T | undefined>;
+
+declare function useStateRef<T>(initialState?: T): [
+    typeof initialState extends undefined ? T | undefined : T,
+    Dispatch<SetStateAction<typeof initialState extends undefined ? T | undefined : T>>,
+    MutableRefObject<typeof initialState extends undefined ? T | undefined : T>
+];
+
+/**
+ * Este hook es una simplificación de la dinámica de suscripción con cambio de
+ * estado ante eventos.
+ *
+ * @example
+ *
+ * useIsAfter = (id: string) => {
+    return useSubscription({
+      getInitialState: () => {
+        return { isAfter: this.#isAfter(id), isBefore: this.#isBefore(id) };
+      },
+      makeSubscription: (setState) => {
+        return this.#emitter.on('hover', () => {
+          setState({
+            isAfter: this.#isAfter(id),
+            isBefore: this.#isBefore(id),
+          });
+        });
+      },
+    });
+  };
+ */
+declare function useSubscription<T>({ getInitialState, makeSubscription, }: {
+    getInitialState?: (() => T) | (() => () => T);
+    makeSubscription: (setState: Dispatch<SetStateAction<T>>) => () => void;
+}): T;
+
+/**
+ * Este hook se comporta igual que useEffect, con la diferencia de que en el
+ * primer renderizado no se va a ejecutar.
+ */
+declare function useUpdateEffect(effect: EffectCallback, deps?: DependencyList): void;
+
+declare function shallowEqual(a: unknown, b: unknown): boolean;
+/**
+ * Compara con shallowEqual todos los ítems de dos arrays
+ */
+declare function shallowCompareArrays(a: unknown[], b: unknown[]): boolean;
+declare function useShallowMemo<T>(creator: () => T, deps: unknown[]): T;
+
+declare function useWhyUpdated(label: any, e: Record<string, any>): void;
+
+type TMethod<CR> = CR extends (state: any, ...args: infer Action) => any ? (id: TId, ...args: Action) => unknown : () => unknown;
+type TMethods<State extends TMap, K extends any[] = any[]> = Record<string, (setState: TStateManager<State>, ...args: K) => void>;
+type TMethodsMap<OriginalMethods extends TMethods<any>> = {
+    [Name in keyof OriginalMethods]: TMethod<OriginalMethods[Name]>;
+};
+type TEventsMap<OriginalEvents extends TMap> = {
+    [Name in keyof OriginalEvents]: (args: OriginalEvents[Name]) => unknown;
+};
+type TEventsHandlers<OriginalEvents extends TMap> = Record<TId, {
+    [Name in keyof OriginalEvents]?: {
+        cb: (args?: OriginalEvents[Name]) => unknown;
+        uniqueHookId: string;
+    }[];
+}>;
+type TMap = Record<string, any>;
+type TStateManager<State> = (newState: Partial<State>) => void;
+type TFireEvent<Events extends TMap> = <K extends keyof Events>(id: TId, ev: K, args: Events[K] extends void ? undefined : Events[K]) => void;
+
+/**
+ * Permite la creación de componentes multi-instancia que ofrecen métodos para
+ * trabajar sobre su estado o su comportamiento interno.
+ *
+ * @example
+ * const [methods, events, Imperative] = makeImperativeComponent<
+    {
+      age: number;
+    },
+    { blink: number }
+  >()(
+    {} as {
+      name: string;
+    },
+    {
+      setName(setState, name: string) {
+        setState({ name });
+      },
+    },
+    ({ age, name, useEvents }) => {
+      const [isBlinking, setIsBlinking] = useState(false);
+
+      useEvents({
+        blink() {
+          setInterval(() => setIsBlinking((current) => !current), 300);
+        },
+      });
+
+      return (
+        <Box sx={{ background: isBlinking ? 'red' : undefined }}>
+          {age} {name}
+        </Box>
+      );
+    },
+  );
+
+  methods
+ */
+declare function makeImperativeComponent<ComponentProps extends TMap, Events extends TMap = TMap>(): <State extends TMap, Methods extends TMethods<State>>({ Component, initialState, methods, }: {
+    initialState?: State | undefined;
+    methods?: Methods | undefined;
+    Component: FC<Omit<ComponentProps, 'id'> & State>;
+}) => [
+    TMethodsMap<Methods>,
+    TFireEvent<Events>,
+    FC<ComponentProps & {
+        id: TId;
+    }>
+];
+
+type TSingleMethodsMap<Methods extends TMethods<any>, MethodsMap extends TMethodsMap<Methods>> = {
+    [Name in keyof MethodsMap]: MethodsMap[Name] extends (id: TId, ...args: infer Action) => unknown ? (...args: Action) => unknown : never;
+};
+declare function makeSingleImperativeComponent<ComponentProps extends TMap, Events extends TMap = TMap>(): <State extends TMap, Methods extends TMethods<State>>({ initialState, methods, Component, }: {
+    initialState?: State | undefined;
+    methods?: Methods | undefined;
+    Component: FC<Omit<ComponentProps, 'id'> & State>;
+}) => [TSingleMethodsMap<Methods, TMethodsMap<Methods>>, <K extends keyof Events>(ev: K, args: Events[K]) => void, FC<ComponentProps>];
+
+declare const useImperativeComponentEvents: <Events extends TMap = TMap>(handlers: Partial<TEventsMap<Events>>) => string;
+
+/**
+ * Permite el uso de eventos en herederos directos o no del imperativeComponent
+ * más cercano.
+ */
+declare function useImperativeComponentContext<Events extends TMap = TMap>(): {
+    id: TId;
+    eventsStore: TEventsHandlers<Events>;
+};
+
+/**
+ * Dado un nombre de etiqueta, devuelve el texto que esa etiqueta contiene en
+ * el idioma actual. En este momento, lo único que hace realmente esta función
+ * es devolver la variable del window con el mismo nombre que se está
+ * pidiendo.
+ *
+ * La idea de implementar esta función, es que en un futuro la fuente de la
+ * que provienen las labels pueda ser más diversa.
+ *
+ * Permite el pasaje de tokens para el reemplazo automático de los mismos.
+ *
+ * @example
+ *
+ * // Suponemos la etiqueta msgUsu = { text: 'Usuario <TOK1>', title: 'Usuario <TOK1>' }
+ *
+ * getLabel('msgUsu' , {
+ *   text: {
+ *     TOK1: 'admin',
+ *   },
+ *   title: {
+ *     TOK1: 'no disponible',
+ *   }
+ * })
+ */
+declare function getLabel(name: string, replaceTokens?: {
+    text?: Record<string, string>;
+    title?: Record<string, string>;
+}): {
+    text: string;
+    tooltip: string;
+};
+
+/**
+ * Da formato a un mensaje con tokens incrustados.
+ *
+ * @example
+ *
+ * // Dado el siguiente mensaje:
+ * var msg = 'El campo <TOK1> es inválido.';
+ *
+ * console.log(formatMessage(msg, {
+ *  TOK1: 'nombre',
+ * }));
+ * // Imprime: El campo nombre es inválido.
+ */
+declare const formatMessage: (str: string, obj: {
+    [key: string]: string;
+}) => string;
+
+interface ISetBoundary {
+    number?: number | string;
+    min?: number;
+    max?: number;
+    loop?: boolean;
+}
+/**
+ * Añade límites a un número, impidiendo que sea
+ * inferior o superior a los límites establecidos.
+ *
+ * Si se pasa loop en true, al llegar al valor maximo o minimo regresara al
+ * minimo o maximo respectivamente.
+ */
+declare function addBoundary(num: number, min: number, max?: number, loop?: boolean): number;
+declare function addBoundary(definition: ISetBoundary): number;
+/**
+ * Esta función acepta un número y devuelve la representaciíon
+ * en string de su tamaño en disco. Ej: 1024 => 1kb
+ */
+declare function parseAsSize(num: number): string;
+/**
+ * Toma cualquier valor y devuelve siempre un número. En caso de que el valor
+ * casteado con la función Number(value) de NaN, devuelve defaultReturn, que por
+ * defecto es 0
+ */
+declare function noNaN(number: unknown, defaultReturn?: number): number;
+
+/**
+ * Este método itera sobre un objeto hasta encontrar la ruta especificada
+ *
+ * @example
+ *
+  const obj = {
+    a: {
+      b: {
+        c: {
+          d: "d"
+        }
+      }
+    }
+  };
+
+  console.log(getValueByPath(obj,'a.b.c')) // { d: 'd' }
+  console.log(getValueByPath(obj,'a.b.c.d')) // 'd'
+ *
+ */
+declare function getValueByPath(obj: Record<string, unknown>, path: string | string[], separator?: string): unknown;
+
+/**
+ * Permite escribir una propiedad en un objeto, en una ruta especificada. Si
+ * dicha ruta no existe dentro del objeto la crea, siempre que sea posible. No
+ * será posible en caso de que alguno de los elementos de la ruta contenga una
+ * propiedad que no sea de tipo objeto.
+ *
+ * @param obj El objeto donde se desea escribir la propiedad
+ * @param path La ruta en la que se va a escribir
+ * @param value El valor que se va a escribir en la ruta especificada
+ * @returns Un objeto idéntico del recibido pero co nlos cambios aplicados
+ *
+ * @throws { Error } En caso de que la ruta especificada contenga algún elemento que no puede ser escrito.
+ *
+ * @example
+ *
+ * const a = {
+ *  a: {}
+ * };
+ *
+ * setValueByPath(a, 'a.b.c', 'Hello world');
+ * /* Outputs:
+ * {
+ *  a: {
+ *    b: {
+ *      c: 'Hello world'
+ *    }
+ *  }
+ * }
+ */
+declare function setValueByPath(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown> | null;
+
+type TProperties = Record<string, unknown>;
+type TPropsSuscriptor<PropsType extends Record<string, unknown> = TProperties> = (props: PropsType, urgent?: boolean) => unknown;
+type TPropsSelector<Selected = any, PropsType = TProperties> = (props: PropsType) => Selected;
+/**
+ * La función comparadora debe devolver true cuando
+ * los elementos son iguales o false cuando son
+ * distintos.
+ */
+type TPropsComparator<Selected> = (prevProps: Selected | undefined, newProps: Selected | undefined) => boolean;
+type TPropsConfiguration<Selected, PropsType extends Record<string, unknown> = TProperties> = {
+    selector?: TPropsSelector<Selected, PropsType>;
+    comparator?: TPropsComparator<Selected>;
+    initialValue?: Selected;
+    propsStore?: PropsStore<PropsType>;
+};
+type TUpdateFieldConfiguration = Partial<{
+    noEmit: boolean;
+    isUrgent: boolean;
+}>;
+
+declare const PropsSelectorUndefinedObject: {};
+interface IPropsStoreConf {
+    logCommands: {
+        propsStore?: string;
+        updateProp?: string;
+        propsSuscriptors?: string;
+        propsLog?: string;
+    };
+}
+declare class PropsStore<PropsType extends Record<TId, unknown> = Record<TId, unknown>> {
+    private configuration?;
+    log: unknown;
+    fields: Record<TId, PropsType>;
+    suscriptors: Record<TId, TPropsSuscriptor<PropsType>[]>;
+    loggers: Record<string, (props: unknown[]) => void>;
+    constructor(configuration?: IPropsStoreConf | undefined);
+    destructor(): void;
+    getAllFields(): Record<TId, PropsType>;
+    /**
+     * Devuelve los props actuales de un campo.
+     */
+    getFieldProps<ParsedPropsType = PropsType>(fieldId: TId): ParsedPropsType;
+    removeField(fieldId: TId): void;
+    /**
+     * Permite establecer un suscriptor que será llamado
+     * cada vez que las props del campo especificado cambien.
+     */
+    suscribe(fieldId: TId, callback: TPropsSuscriptor<PropsType>): () => void;
+    /**
+     * Actualiza o crea las props de un campo.
+     *
+     * La tercera prop está relacionada
+     */
+    updateField<NewPropsType extends Record<TId, unknown> = Partial<PropsType>>(fieldId: TId, props: Partial<NewPropsType>, conf?: TUpdateFieldConfiguration): void;
+}
+declare const propsStore: PropsStore<TProperties>;
+
+declare function isPropsConfigurationObject<Selected, PropsType extends Record<string, unknown> = TProperties>(value?: TPropsSelector<Selected, PropsType> | TPropsConfiguration<Selected, PropsType>): value is TPropsConfiguration<Selected, PropsType>;
+/**
+ *
+ * Este hook permite escuchar los cambios en las propiedades
+ * de un campo en particular.
+ *
+ * @param configuration
+ * Este objeto permite pasar las siguientes propiedades para ser
+ * determinar el comportamiento del hook:
+ *
+ * **selector:** La función selectora es una función equivalente
+ * a la que se utiliza en el useAppSelector de redux. Con ella
+ * se puede seleccionar una porción de las props, evitando
+ * re-renderizados innecesarios. Esto se debe a que el renderizado
+ * solamente ocurrirá cuando la función selectora devuelva un valor
+ * que sea distinto del anterior.
+ *
+ * El concepto de distinto es: si existe una función comparadora,
+ * se determinará mediante la ejecución de dicha función, a la que
+ * se le pasan como parámetros el objeto anterior y el nuevo.
+ *
+ * En caso de que no haya función comparadora, se comparará que
+ * las props seleccionadas y las nuevas sean exactamente las mismas
+ * (la referencia al mismo objeto).
+ *
+ * **comparator:** La función comparadora de la que estamos
+ * hablando.
+ *
+ * **initialValue:** Un valor para setearlo al inicio, el mismo
+ * solamente será seteado en caso de que ya no exista un valor
+ * en el store.
+ * @returns
+ */
+declare function usePropsSelector<Selected = TProperties, PropsType extends Record<string, unknown> = TProperties>(fieldId: TId, configuration?: TPropsConfiguration<Selected, PropsType>): Selected;
+/**
+ *
+ * Este hook permite escuchar los cambios en las propiedades
+ * de un campo en particular.
+ *
+ * @param selector La función selectora es una función equivalente
+ * a la que se utiliza en el useAppSelector de redux. Con ella
+ * se puede seleccionar una porción de las props, evitando
+ * re-renderizados innecesarios. Esto se debe a que el renderizado
+ * solamente ocurrirá cuando la función selectora devuelva un valor
+ * que sea distinto del anterior.
+ *
+ * El concepto de distinto es: si existe una función comparadora,
+ * se determinará mediante la ejecución de dicha función, a la que
+ * se le pasan como parámetros el objeto anterior y el nuevo.
+ *
+ * En caso de que no haya función comparadora, se comparará que
+ * las props seleccionadas y las nuevas sean exactamente las mismas
+ * (la referencia al mismo objeto).
+ *
+ * @param comparator La función comparadora de la que estamos
+ * hablando.
+ *
+ * @returns
+ */
+declare function usePropsSelector<Selected = TProperties, PropsType extends Record<string, unknown> = TProperties>(fieldId: TId, selector?: TPropsSelector<Selected, PropsType> | TPropsConfiguration<Selected, PropsType>, comparator?: TPropsComparator<Selected>, anotherPropsStore?: PropsStore<PropsType>): Selected;
+
+/**
+ * El hook useDomState permite aplicar propiedades a un
+ * elemento del DOM de la forma más eficiente posible.
+ *
+ * Este hook no permite el uso de sx ya que por las características
+ * del sx, el re-renderizado es necesario.
+ *
+ * @example
+ *
+ *
+ * const TestComponent = () => {
+  const { domProps, setDomProps } = useDomState<BoxProps>({
+    style: {
+      position: 'fixed',
+      left: 0,
+      top: 0,
+      width: '150px',
+      height: '150px',
+      backgroundColor: '#ccc',
+    },
+  });
+  const initialPosition = React.useRef({ boxX: 0, boxY: 0, x: 0, y: 0 });
+  const isDragging = React.useRef(false);
+  const [state, setState] = React.useState(1);
+
+  React.useEffect(() => {
+    const move = (ev: MouseEvent) => {
+      if (isDragging.current) {
+        const moveX = ev.clientX - initialPosition.current.x;
+        const moveY = ev.clientY - initialPosition.current.y;
+        const newLeft = initialPosition.current.boxX + moveX;
+        const newTop = initialPosition.current.boxY + moveY;
+        setDomProps({
+          style: {
+            left: `${newLeft}px`,
+            top: `${newTop}px`,
+          },
+        });
+      }
+    };
+
+    const removeSuscription = () => {
+      isDragging.current = false;
+    };
+
+    document.addEventListener('mousemove', move);
+    document.addEventListener('mouseup', removeSuscription);
+
+    return () => {
+      document.removeEventListener('mousemove', move);
+      document.removeEventListener('mouseup', removeSuscription);
+    };
+  }, [setDomProps]);
+
+  return (
+    <Box
+      {...domProps}
+      onMouseDown={(ev) => {
+        initialPosition.current = {
+          boxX: Number.parseInt(domProps.style?.left as string, 10),
+          boxY: Number.parseInt(domProps.style?.top as string, 10),
+          x: ev.clientX,
+          y: ev.clientY,
+        };
+        isDragging.current = true;
+      }}
+    >
+      Esta caja es arrastrable. Renderizados: {state}
+      <Button onClick={() => setState((current) => current + 1)}>
+        Renderizar
+      </Button>
+    </Box>
+  );
+};
+ */
+declare function useDomState<T extends HTMLAttributes<HTMLElement>>(initialDomProps?: T): {
+    domProps: T & {
+        ref: (el: HTMLElement) => void;
+    };
+    setDomProps: ({ style, ...newDomProps }: Partial<T>) => void;
+};
+
+/**
+ * Permite manejar un estado que se actualizará únicamente siguiendo el
+ * comportamiento esperado de un debounce
+ */
+declare function useDebouncedState<T>(timeout: number, initialState?: T): [T | undefined, (state: SetStateAction<T>, immediate?: boolean) => unknown];
+
+declare class ScreenLocker extends EventEmitter<{
+    forcedStateChange: {
+        hasReleasedFirstTime: boolean;
+        isForced: boolean;
+    };
+    lockStateChange: {
+        hasReleasedFirstTime: boolean;
+        isLocked: boolean;
+        lockName: string;
+    };
+    releaseForFirstTime: null;
+    ready: null;
+}> {
+    #private;
+    get hasReleasedFirstTime(): boolean;
+    get isForced(): boolean;
+    /**
+     * Permite saber si un bloqueo determinado está activo o si la clase tiene
+     * forceLock activo.
+     */
+    isLocked(lockName?: string): boolean;
+    constructor();
+    lock(lockName?: string): void;
+    unlock(lockName?: string): void;
+    force(): void;
+    releaseForced(): void;
+}
+/**
+ * Esta clase no implementa ninguna funcionalidad de bloqueo, sino solamente se
+ * encarga de la lógica y de los eventos.
+ *
+ * El concepto es que hay n niveles de bloqueo y además existe el bloqueo
+ * forzado. Cada uno de los niveles recibe un nombre, por defecto se realizan
+ * operaciones contra el bloque 'common' si no se pasa ninguno, pero
+ * podría utilizarse cualquier otro. Esto es así con el fin de implementar
+ * varios bloqueos en la misma clase, ejemplos: el bloqueo común, el bloqueo
+ * lineal de las tablas, bloque con pantalla blanca en el inicio de formularios,
+ * o cualquier otro que se desee. Para los bloqueos estándar se utilizan los
+ * métodos lock y unlock.
+ *
+ * El bloqueo forzado por otra parte es un estado general que se puede alterar
+ * mediante los métodos force y releaseForced. Cada vez que se bloquee o
+ * desbloquee la pantalla, se lanzará un evento lockStateChange sin lockName y
+ * con forced = true.
+ *
+ * Además, provee un evento para saber cuándo se desbloquea la pantalla
+ * efectivamente por primera vez para cada tipo de bloqueo. Es posible a su vez
+ * resetear la clase para que este evento sea lanzado nuevamente en el próximo
+ * desbloqueo mediante resetRefreshFirstTime.
+ *
+ * El evento releasForFirstTime se dispara únicamente para el bloqueo 'common'.
+ * Esto es así ya que sino podría dar lugar a confusión en situaciones donde no
+ * se controle el nombre del bloqueo.
+ */
+declare const screenLocker: ScreenLocker;
+
+type StatefulStoreUnsuscriber = () => void;
+type StatefulStoreUpdater<Props> = (currentProps: Props) => Props;
+type StatefulStoreUpdateProps<Props> = StatefulStoreUpdater<Props> | Partial<Props>;
+/**
+ * Clase facilitadora del uso de StatefulStore. Es un pequeño almacen que
+ * permite actualizar sus propiedades y sabe cómo sincronizarse con el store de
+ * modo que los cambios se propaguen según corresponda.
+ */
+declare abstract class BasicStoredElement<Props extends Record<string, unknown>> {
+    #private;
+    abstract getId(): TId;
+    onUpdate(cb: () => void): StatefulStoreUnsuscriber;
+    props: Props;
+    constructor(props: Props);
+    protected shoutUpdates: () => void;
+    update(newProps: StatefulStoreUpdateProps<Props>): void;
+    useProps: () => Props;
+}
+/**
+ * Son las acciones de adición del store.
+ */
+type AddActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `add${Capitalize<string & P>}`]: (el: T[P]) => void;
+};
+/**
+ * Acciones de vaciado del store.
+ */
+type EmptyActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `empty${Capitalize<string & P>}`]: () => void;
+};
+/**
+ * Acciones de removido del store.
+ */
+type RemoveActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `remove${Capitalize<string & P>}`]: (id: TId) => void;
+};
+type UpdateListActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `update${Capitalize<string & P>}List`]: (newList: T[P]) => void;
+};
+/**
+ * Conjunto de acciones disponibles del store
+ */
+type ActionMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    actions: AddActions<T> & EmptyActions<T> & RemoveActions<T> & UpdateListActions<T>;
+};
+/**
+ * Método que permite obtener el listado de elementos de un tipo.
+ */
+type GetStateActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `get${Capitalize<string & P>}State`]: () => T[P][];
+};
+/**
+ * Método que permite conocer las propiedades de un elemento.
+ */
+type GetItemActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `get${Capitalize<string & P>}`]: (id: TId) => T[P];
+};
+type UpdateItemActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `update${Capitalize<string & P>}`]: (id: TId, newProps: StatefulStoreUpdateProps<T[P]['props']>) => void;
+};
+/**
+ * Conjunto de métodos que permiten acceder al estado en un momento
+ * determinado.
+ */
+type StateMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    state: GetStateActions<T> & GetItemActions<T> & UpdateItemActions<T>;
+};
+/**
+ * Es el hook encargado de permitir la escucha de listado de elementos y sus
+ * propiedades.
+ */
+type HookUseState<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `use${Capitalize<string & P>}`]: () => T[P][];
+};
+/**
+ * Es el hook encargado de permitir la escucha de listado de elementos
+ */
+type HookUseList<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `use${Capitalize<string & P>}List`]: () => T[P][];
+};
+/**
+ * Es el hook encargado de permitir la escucha de propiedades de un elemento
+ */
+type HookUseStateById<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `use${Capitalize<string & P>}ById`]: (id: TId) => T[P] | undefined;
+};
+/**
+ * Conjunto de hooks del store.
+ */
+type HooksMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    hooks: HookUseState<T> & HookUseStateById<T> & HookUseList<T>;
+};
+/**
+ * Es la suscripción encargada de permitir la escucha de propiedades de un
+ * elemento
+ */
+type SuscribeById<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `change${Capitalize<string & P>}Element`]: (id: TId, cb: (props: T[P]) => unknown) => StatefulStoreUnsuscriber;
+};
+/**
+ * Es la suscripción encaragada de permitir la escucha de cambios en la lista y
+ * las propiedades de sus elementos.
+ */
+type SuscribeToListChange<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `change${Capitalize<string & P>}`]: (cb: (props: T[P][]) => unknown) => StatefulStoreUnsuscriber;
+};
+/**
+ * Es la suscripción encaragada de permitir la escucha de cambios en la
+ * cantidad de elementos de la lista, pero no en las propiedades de los
+ * elementos.
+ */
+type SuscribeToListCountChange<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `change${Capitalize<string & P>}Ammount`]: (cb: (props: T[P][]) => unknown) => StatefulStoreUnsuscriber;
+};
+type SuscribeMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    on: SuscribeById<T> & SuscribeToListChange<T> & SuscribeToListCountChange<T>;
+};
+type InitialStates<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `${string & P}State`]: T[P][];
+};
+/**
+ * Este store permite mantener `N` listados de objetos y por cada tipo de
+ * objeto ofrece métodos para agregar, eliminar, obtener uno, obtener todos y
+ * un hook para conocer el listado en tiempo real.
+ *
+ * **Métodos disponibles**
+ *
+ *  - **action.addXXX**: Agrega un elemento de tipo XXX a la lista.
+ *  - **action.emptyXXX**: Vacía el listado de tipo XXX.
+ *  - **action.removeXXX**: Elimina un elemento de tipo XXX de la lista.
+ *  - **action.updateXXXList**: Permite actualizar toda la lista en una sola
+ *  acción. - **hooks.useXXX**: Permite conocer el listado de elementos y el
+ *  cambio
+ *  en sus propiedades en tiempo real.
+ *  - **hooks.useXXXById**: Permite conocer los cambios a un elemento de la
+ *  lista en tiempo real.
+ *  - **hooks.useXXXList**: Permite conocer el listado de
+ *  elementos pero no reacciona a los cambios en las propiedades de los
+ *  elementos.
+ *  - **on.changeXXX**: Permite suscribirse al listado de elementos y
+ *  cambios en sus propiedades.
+ *  - **on.changeXXXAmmount**: Permite suscribirse
+ *  al listado de elementos, sin tomar en cuenta el cambio en las propiedades
+ *  de sus items.
+ *  - **on.changeXXXElement**: Permite suscribirse al cambio de
+ *  propiedades de un ítem particular
+ *  - **state.getXXX**: Permite obtener el
+ *  esatdo de un elemento particular de la lista.
+ *  - **state.getXXXState**:
+ *  Permite obtener el estado del listado completo de un tipo de elementos.
+ *  - **state.updateXXX**: Es un atajo para state.getXXX(id).update
+ *
+ * La funcionalidad de actualización se implementa en el objeto almacenado y es
+ * comunicada en forma automática al store, de forma que el store no conoce
+ * solamente cuántos y cuáles elementos hay almacenados, sino que además refleja
+ * en tiempo real el estado de sus propiedades.
+ *
+ * @example
+ *
+    type TPeople = { name: string };
+    class People extends BasicStoredElement<TPeople> {
+      getId(): TId {
+        return this.props.name;
+      }
+    }
+
+    class Schedule extends BasicStoredElement<{ day: string; task: string }>
+    {
+      getId() {
+        return this.props.day;
+      }
+    }
+
+    const r = makeStatefulStore(
+      {
+        people: People.prototype,
+        schedules: Schedule.prototype,
+      },
+      {
+        peopleState: [new People({ name: 'A' }), new People({ name: 'B' })],
+      },
+    );
+
+    const p = r.hooks.usePeople();
+    p[0].props.name;
+
+    r.hooks.usePeople();
+
+    r.actions.removePeople('asdf');
+
+    r.actions.addPeople(new People({ name: 'asdf' }));
+    r.actions.removePeople('asdf');
+
+    r.state.getPeopleState();
+    const pep = r.state.getPeople('asdf')
+
+    const ph = r.hooks.usePeople();
+    const sch = r.hooks.useSchedules();
+ */
+declare function makeStatefulStore<T extends Record<string, BasicStoredElement<any>>>(entries: T, initialStates?: Partial<InitialStates<T>>): ActionMethods<T> & HooksMethods<T> & StateMethods<T> & SuscribeMethods<T>;
+
+declare const persistentStorage: {
+    [key: string]: unknown;
+    remove(prop: string): unknown;
+};
+declare global {
+    interface Window {
+        persistentStorage: typeof persistentStorage;
+    }
+}
+
+/**
+ * @param prop este nombre define el nombre del localStorage, las modificaciones a este parametro no van a tener efecto.
+ */
+declare function useLocalStorage<T>(prop: string, defaultValue?: T): [T, (newValue: T) => void];
+
+/**
+ * Calculates the alignment distance between two strings using the Levenshtein
+ * distance algorithm. This distance is defined as the minimum number of
+ * single-character edits (insertions, deletions, or substitutions) required to
+ * change one string into the other. The function implements a dynamic
+ * programming approach to efficiently compute this metric.
+ *
+ * @param {string} a - The first string to compare.
+ * @param {string} b - The second string to compare.
+ * @returns {number} The alignment distance between the two strings. This is a non-negative integer where
+ * a value of 0 indicates that the strings are identical, and a larger value
+ * indicates a greater degree of difference.
+ *
+ * @example
+ * // returns 3
+ * alignment("kitten", "sitting");
+ *
+ * @example
+ * // returns 2
+ * alignment("flaw", "lawn");
+ */
+declare function alignment(a: string, b: string): number;
+
+declare function ucfirst(word: string): string;
+
+/**
+ * Toma un valor y devuelve true o false según las
+ * siguientes condiciones:
+ *
+ * Si es string, ['',
+ * 'false'].includes(value.toLowerCase()) => false, todo lo
+ * demás => true.
+ *
+ * Si es array, [] => false, [...] => true.
+ *
+ * Todo lo demás !!value
+ *
+ * @example
+ *
+ * toBoolean('true') // true
+ * toBoolean('TrUE') // true
+ * toBoolean('FAlSe') // false
+ * toBoolean(0) // false
+ * toBoolean(1) // true
+ * toBoolean([0]) // true
+ * toBoolean([]) // false
+ */
+declare function toBoolean(value: unknown): boolean;
+
+declare const parseXmlAsync: <T>(xml: string) => Promise<T>;
+
+export { BasicStoredElement, BouncingEmitter, type Callback, type DebounceOptions, type DownloadStringAsDocProps, EventEmitter, History, type IOnFocusConfiguration, type IParameter, type ISetBoundary, type Map, PropsSelectorUndefinedObject, PropsStore, StatefulEmitter, type StatefulStoreUpdateProps, type StatefulStoreUpdater, type TApiaAction, type TApiaActions, type TApiaCellDefinition, type TApiaComplexCell, type TApiaFieldPropsObj, type TApiaFilter, type TApiaFilterOption, type TApiaFilterValue, type TApiaFormButton, type TApiaFormElement, type TApiaFormElementOption, type TApiaFunction, type TApiaFunctionPageInfo, type TApiaLoad, type TApiaLoadForm, type TApiaLoadText, type TApiaMessage, type TApiaMultiplePossibleValue, type TApiaPossibleValue, type TApiaRadioPossibleValue, type TApiaRowDefinition, type TApiaSelectPossibleValue, type TApiaSystemMessageObj, type TApiaTableFunction, type TCallback, type TDateFormat, type TDispatchCallback, type TFieldEvent, type TFieldScriptEvent, type TFieldScriptEvents, type TFieldServerEvent, type TFieldServerEvents, type TFncParams, type TFocusRetriever, type THistoryCount, type THistoryStep, type THistoryStepChange, type TId, type TKey, type TMap$1 as TMap, type TMessage, type TModify, type TNotificationMessage, type TPropsComparator, type TPropsConfiguration, type TPropsSelector, type TRequireOnlyOne, type TShortcutBranch, type TUpdateFieldConfiguration, type ThrottleOptions, type UnSubscriber, Url, addBoundary, alignment, animate, apiaDateToStandarFormat, arrayOrArray, autoDisconnectMutationObserver, cantFocusSelector, customEvents, dateToApiaFormat, debugDispatcher, decodeHTMLEntities, decrypt, defaultGetNameFromResponse, disableChildrenFocus, downloadStringAsDoc, downloadUrl, enableChildrenFocus, encrypt, findOffsetRelativeToScrollParent, findScrollContainer, focus, focusSelector, formatMessage, getDateFormat, getFocusSelector, getIndex, getLabel, getSpecificParent, getValueByPath, globalFocus, isChild, isDebugDispatcherEnabled, isPropsConfigurationObject, isSetter, makeImperativeComponent, makeSingleImperativeComponent, makeStatefulStore, noNaN, notificationsSelector, openAndReadFile, parseAsSize, parseXmlAsync, persistentStorage, propsStore, screenLocker, scrollParentIntoElement, setValueByPath, shallowCompareArrays, shallowEqual, shortcutController, toBoolean, ucfirst, useCombinedRefs, useDebouncedCallback, useDebouncedState, useDomState, useImperativeComponentContext, useImperativeComponentEvents, useIntermediateValue, useLatest, useLocalStorage, useMount, usePanAndZoom, usePrevious, usePropsSelector, useShallowMemo, useStateRef, useSubscription, useUnmount, useUpdateEffect, useWhyUpdated };
 //# sourceMappingURL=index.d.ts.map