@apia/util 0.0.7 → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1643 @@
+import * as React$1 from 'react';
+import React__default, { EffectCallback, Dispatch, SetStateAction, MutableRefObject, DependencyList, FC, HTMLAttributes } from 'react';
+import { AxiosResponse } from 'axios';
+import * as theme_ui_jsx_runtime from 'theme-ui/jsx-runtime';
+import { TIconName, TIconType } from '@apia/icons';
+import { TId as TId$1 } from '@apia/util';
+
+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) => string;
+
+declare const encrypt: (salt: string, iv: string, passPhrase: string, plainText: string, keySize: number, iterationCount: number) => 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;
+
+/**
+ * Indica si el debugDispatcher fue activado, lo que en muchos casos indica que
+ * estamos en ambiente de desarrollo
+ */
+declare function isDebugDispatcherEnabled(): boolean;
+/**
+ * El debug dispatcher solamente debería activarse en modo desarrollo. Este
+ * control solamente puede hacerse desde la aplicación principal, por ello, para
+ * activar el debugDispatcher se exporta este método que debe llamarse cuando
+ * sea correcto.
+ */
+declare function enableDebugDispatcher(): void;
+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$1.categories, fireEvenFromInputs?: boolean): void;
+};
+
+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;
+
+/**
+ * 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>;
+
+/**
+ * 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>;
+};
+
+type TEventMap = Record<string, any>;
+type TEventKey<T extends TEventMap> = string & keyof T;
+type TEventReceiver<T> = (params: T) => unknown;
+type TFun = () => unknown;
+interface IEmitter<T extends TEventMap> {
+    on<K extends TEventKey<T>>(eventName: K, fn: TEventReceiver<T[K]>): TFun;
+    off<K extends TEventKey<T>>(eventName: K, fn: TEventReceiver<T[K]>): unknown;
+    emit<K extends TEventKey<T>>(eventName: K, params?: T[K]): unknown;
+}
+/**
+ * EventEmitter muy sencillo.
+ *
+ * El siguiente ejemplo es un fragmento de una clase
+ * perteneciente al grupo de wai-aria helpers. Ver que el método #shout nada
+ * tiene que ver con la clase EventEmitter, sino que es un  método interno de la
+ * clase WaiTypeAhead.
+ *
+ * Lo que realmente importa en el ejemplo es el tipado (Lo que va luego de
+ * extends EventEmitter) y el this.emit en la creación del emitter; por otra
+ * parte es importante el (instance).on(...) que se muestra al final del
+ * ejemplo, que permite realizar suscripciones al EventEmitter creado.
+ *
+ * Además, es notable que cuando se realiza una suscripción mediante
+ * (instance).on, este método devuelve un método que al ser llamado rompe la
+ * suscripción; esto nos da la firma del método on como:
+ *
+ * on(eventName: string, callback: (ev: eventType) => unknown): Unsuscriptor;
+ *
+ * @example
+ *
+ * // Event emitter creation
+ *
+ * class WaiTypeAhead extends EventEmitter<{
+      multipleKeys: string;
+      singleKey: string;
+    }> {
+      // ...
+      #shout({ clear } = { clear: true }) {
+        if (this.typing.length === 1) {
+          this.emit('singleKey', this.typing);
+        } else if (this.typing.length > 1) {
+          this.emit('multipleKeys', this.typing);
+        }
+        // ...
+      }
+      // ...
+    }
+
+    // Usage
+
+    const wtype = new WaiTypeAhead();
+    wtype.on('multipleKeys', (typing) => {
+      write(`Multiple: ${typing}`);
+    });
+ */
+declare class EventEmitter<T extends TEventMap> implements IEmitter<T> {
+    #private;
+    on<K extends TEventKey<T>>(eventName: K, fn: TEventReceiver<T[K]>): () => void;
+    off<K extends TEventKey<T>>(eventName: K, fn: TEventReceiver<T[K]>): void;
+    emit<K extends TEventKey<T>>(eventName: K, params?: T[K]): void;
+}
+
+type TLiveEvent = {
+    message: string;
+    type: 'polite' | 'assertive' | 'reset';
+};
+/**
+ * Este método se utiliza para emitir mensajes
+ * a los usuarios con discapacidades. **IMPORTANTE:
+ * El empleo de esta herramienta debe ser analizado
+ * a conciencia**.
+ *
+ * **La forma que considero correcta de analizar el
+ * problema es:**
+ *
+ * Si yo fuera un usuario ciego o discapacitado, qué
+ * tipo de mensaje me gustaría recibir para entender
+ * el uso de las herramientas en el contexto actual.
+ *
+ * Si se encuentra que esta forma de analizar el
+ * problema tiene fallos o carencias, por favor
+ * iniciar la discusión correspondiente ya que la idea
+ * es ir mejorando esta herramienta.
+ *
+ * **El uso es muy sencillo:**
+ *
+ * Al llamar al método
+ * AriaLiveEmitter.emit({ live: 'polite' | 'assertive',
+ * message: 'un mensaje' }), se actualiza un div para
+ * que contenta estas características, lo que termina
+ * leyendo dicho mensaje al usuario.
+ */
+declare const AriaLiveEmitter: {
+    "__#1@#emitter": IEmitter<{
+        live: TLiveEvent;
+    }>;
+    on<K extends "live">(eventName: K, fn: TEventReceiver<{
+        live: TLiveEvent;
+    }[K]>): () => void;
+    off<K_1 extends "live">(eventName: K_1, fn: TEventReceiver<{
+        live: TLiveEvent;
+    }[K_1]>): void;
+    emit<K_2 extends "live">(eventName: K_2, params?: {
+        live: TLiveEvent;
+    }[K_2] | undefined): void;
+};
+declare const LiveRegion: () => theme_ui_jsx_runtime.JSX.Element;
+
+/**
+ * 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;
+
+/**
+ * Esta clase ofrece la posibilidad de crear una variable que al ser
+ * actualizada avisa sobre la actualización.
+ *
+ * @example
+ * const name = new WithEventsValue<string>('Alexis Leite');
+ *
+ * name.on('update', (newName) => console.log(`El nuevo nombre es ${newName}`));
+ *
+ * name.value = 'Joel'; // logs "El nuevo nombre es Joel"
+ */
+declare class WithEventsValue<T> extends EventEmitter<{
+    update: T | undefined;
+}> {
+    #private;
+    constructor(value?: T);
+    get value(): T | undefined;
+    set value(value: T | undefined);
+}
+
+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 = {
+    class: string;
+    disabled: boolean;
+    html: boolean;
+    id: string;
+    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: {
+        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;
+};
+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: {
+    "__#6@#root": HTMLElement;
+    "__#6@#props": IFocusProps | undefined;
+    afterNotificationFocus: IFocusQueryElement | undefined;
+    "__#6@#actualFocusQuery": IFocusQueryElement[];
+    "__#6@#currentInstruction": number;
+    "__#6@#focusDelay": number;
+    "__#6@#focusRetries": number;
+    "__#6@#focusTimeout": number;
+    "__#6@#isIntervalRunning": boolean;
+    "__#6@#focusQuery": IFocusQueryElement[];
+    "__#6@#checkInstruction"(focusCheck: IFocusCheck): boolean;
+    "__#6@#doFocus"(HTMLElement: HTMLElement | TFocusRetriever, focusCheck: IFocusCheck, isLastTry: boolean, configuration?: IOnFocusConfiguration): Promise<false | HTMLElement | null>;
+    "__#6@#resetInterval"(): void;
+    "__#6@#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;
+    }, "className" | "id" | "name" | "selector">): 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)[];
+    "__#4@#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;
+};
+
+/**
+ * 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$1.ForwardedRef<unknown> | undefined)[]): React$1.Dispatch<React$1.SetStateAction<RefType | undefined>>;
+
+declare const useDebouncedCallback: <Params extends any[]>(callback: (...params: Params) => unknown, { runWhenTriggered, timeout }?: {
+    runWhenTriggered: boolean;
+    timeout: number;
+}) => (...params: Params) => void;
+
+/**
+ * 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$1.MutableRefObject<T>;
+
+declare function useMount(effect: EffectCallback): void;
+
+declare function useUnmount(unmountCallback: () => void): void;
+
+declare function usePrevious<T>(value: T): React$1.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 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;
+
+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]?: ((args?: OriginalEvents[Name]) => unknown)[];
+}>;
+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, any[]>>({ 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, any[]>>({ 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>>) => void;
+
+/**
+ * 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>;
+};
+
+declare global {
+    interface Window {
+        labels: {
+            [key: string]: {
+                text: string;
+                tooltip: string;
+            };
+        };
+    }
+}
+/**
+ * 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;
+
+type TTabRenderer<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>> = (props: {
+    tab: TTab<AdditionalPropsType>;
+}) => React.ReactElement;
+type TApiaTabProps = {
+    originalUrl: string;
+    url: string;
+};
+type TTab<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>> = {
+    content: React.FunctionComponent<{
+        tab: TTab<AdditionalPropsType>;
+    }>;
+    icon?: TIconName | TIconType;
+    /**
+     * El id es importante ya que se utiliza por temas de accesibilidad. Es
+     * importante asegurarse de que sea único.*/
+    id: TId;
+    isClosable?: boolean;
+    isDisabled?: boolean;
+    /**
+     * Los tabs que estén marcados como fixed aparecerán al inicio del listado.
+     */
+    isFixed?: boolean;
+    isFocused?: boolean;
+    /**
+     * Si se marca como iconTab, se oculta el label y solamente se muestra el
+     * ícono.
+     */
+    isIconTab?: boolean;
+    isLoading?: boolean;
+    isOpen?: boolean;
+    /**
+     * Cuando se cierra un tab que tiene un método onBeforeClose, el mismo será
+     * llamado y deberá devolver un boolean o un string. Si devuelve true, se
+     * cierra. Si devuelve false, se muestra un cartel de confirmación genérico y
+     * si se devuelve un string, se muestra un cartel de confirmación con el
+     * string devuelto. En caso de que el usuario confirme el cuadro de diálogo,
+     * el tab será cerrado de todas formas. Es decir, no hay forma de evitar que
+     * el tab sea cerrado si el usuario decide continuar con la acción. Para
+     * evitar que un tab sea cerrado, debe pasarse isClosable=false
+     */
+    onBeforeClose?: () => boolean | string | Promise<boolean | string>;
+    /**
+     * Este callback será llamado cada vez que el tab sea abierto
+     */
+    onFocus?: (ev: TTab<AdditionalPropsType>) => unknown;
+    /**
+     * Es el texto que se va a mostrar en el tab
+     */
+    label: string;
+    labelRenderer?: TTabRenderer;
+    /**
+     * Se pueden pasar propiedades adicionales que serán recibidas en cada
+     * evento, de forma de poder compartir piezas de información útiles en las
+     * distintas partes de la aplicación.
+     */
+    tabAdditionalProps: AdditionalPropsType;
+    title?: string;
+};
+interface IMainTabsController<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>, TabType extends TTab<AdditionalPropsType> = TTab<AdditionalPropsType>> {
+    activeTabs: TabType[];
+    tabsList: TId[];
+    append(tab: Omit<TabType, 'tabAdditionalProps'> & Partial<Pick<TabType, 'tabAdditionalProps'>>): void;
+    closeAll(closeFixedTabsAsWell?: boolean, force?: boolean): Promise<void>;
+    closeToRight(targetId: TId): Promise<void>;
+    closeToLeft(targetId: TId): Promise<void>;
+    closeOthers(targetId: TId): Promise<void>;
+    closeTab(tabId: TId, force?: boolean): Promise<boolean>;
+    focusNextTab(): TId | null;
+    focusPreviousTab(): TId | null;
+    focusTab(tabId: TId): void;
+    getTabById(tabId: TId): TabType;
+    getTabElement(tabId: TId): Element | null;
+    handleKeyDown(ev: React.KeyboardEvent): void;
+    openNextTab(): TId | null;
+    openPreviousTab(): TId | null;
+    openTab(tabId: TId, justThis?: boolean): void;
+}
+interface ITabsController {
+    handler: IMainTabsController<TApiaTabProps>;
+    handlerSet: boolean;
+    closeActiveTab(force?: boolean): void;
+    closeAll(closeFixedTabsAsWell?: boolean, force?: boolean): void;
+    openMainMenu(): void;
+    openTabByUrl(title: string, url: string, options?: IOpenTabOptions): void;
+    setHandler(handler: IMainTabsController<TApiaTabProps>): void;
+    changeTabState(): void;
+}
+interface IOpenTabOptions {
+    funcId?: TId;
+    keepMenuOpen?: boolean;
+    parentTabId?: 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;
+}>;
+
+interface IPropsStoreConf {
+    logCommands: {
+        propsStore?: string;
+        updateProp?: string;
+        propsSuscriptors?: string;
+        propsLog?: string;
+    };
+}
+declare class PropsStore<PropsType extends Record<TId$1, unknown> = Record<TId$1, unknown>> {
+    private configuration?;
+    log: unknown;
+    fields: Record<TId$1, PropsType>;
+    suscriptors: Record<TId$1, TPropsSuscriptor<PropsType>[]>;
+    loggers: Record<string, (props: unknown[]) => void>;
+    constructor(configuration?: IPropsStoreConf | undefined);
+    destructor(): void;
+    getAllFields(): Record<TId$1, PropsType>;
+    /**
+     * Devuelve los props actuales de un campo.
+     */
+    getFieldProps<ParsedPropsType = PropsType>(fieldId: TId$1): ParsedPropsType;
+    removeField(fieldId: TId$1): void;
+    /**
+     * Permite establecer un suscriptor que será llamado
+     * cada vez que las props del campo especificado cambien.
+     */
+    suscribe(fieldId: TId$1, callback: TPropsSuscriptor<PropsType>): () => void;
+    /**
+     * Actualiza o crea las props de un campo.
+     *
+     * La tercera prop está relacionada
+     */
+    updateField<NewPropsType extends Record<TId$1, unknown> = Partial<PropsType>>(fieldId: TId$1, props: Partial<NewPropsType>, conf?: TUpdateFieldConfiguration): void;
+}
+declare const propsStore: PropsStore<TProperties>;
+
+declare const PropsSelectorUndefinedObject: {};
+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$1, 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$1, 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]);
+
+  console.log('RENDER');
+
+  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];
+
+/**
+ * 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: {
+    "__#5@#hasReleasedFirstTime": boolean;
+    "__#5@#wasReleasedFirstTime": boolean;
+    "__#5@#isForced": boolean;
+    "__#5@#locks": Record<string, boolean>;
+    readonly hasReleasedFirstTime: boolean;
+    readonly isForced: boolean;
+    /**
+     * Permite saber si un bloqueo determinado está activo o si la clase tiene
+     * forceLock activo.
+     */
+    isLocked(lockName?: string): boolean;
+    "__#5@#shoutLockState"(lockName?: string): void;
+    lock(lockName?: string): void;
+    unlock(lockName?: string): void;
+    force(): void;
+    releaseForced(): void;
+    "__#1@#emitter": IEmitter<{
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }>;
+    on<K extends TEventKey<{
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }>>(eventName: K, fn: TEventReceiver<{
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }[K]>): () => void;
+    off<K_1 extends TEventKey<{
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }>>(eventName: K_1, fn: TEventReceiver<{
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }[K_1]>): void;
+    emit<K_2 extends TEventKey<{
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }>>(eventName: K_2, params?: {
+        forcedStateChange: {
+            hasReleasedFirstTime: boolean;
+            isForced: boolean;
+        };
+        lockStateChange: {
+            hasReleasedFirstTime: boolean;
+            isLocked: boolean;
+            lockName: string;
+        };
+        releaseForFirstTime: void;
+        ready: void;
+    }[K_2] | undefined): void;
+};
+
+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];
+
+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>;
+
+declare global {
+    interface Window {
+        [key: string]: string;
+    }
+}
+
+export { AriaLiveEmitter, EventEmitter, IOnFocusConfiguration, IParameter, ISetBoundary, ITabsController, LiveRegion, PropsSelectorUndefinedObject, PropsStore, TApiaAction, TApiaActions, TApiaCellDefinition, TApiaComplexCell, TApiaFieldPropsObj, TApiaFilter, TApiaFilterOption, TApiaFilterValue, TApiaFormButton, TApiaFormElement, TApiaFormElementOption, TApiaFunction, TApiaFunctionPageInfo, TApiaLoad, TApiaLoadForm, TApiaLoadText, TApiaMessage, TApiaMultiplePossibleValue, TApiaPossibleValue, TApiaRadioPossibleValue, TApiaRowDefinition, TApiaSelectPossibleValue, TApiaSystemMessageObj, TApiaTableFunction, TCallback, TDateFormat, TDispatchCallback, TFieldEvent, TFieldScriptEvent, TFieldScriptEvents, TFieldServerEvent, TFieldServerEvents, TFncParams, TFocusRetriever, TId, TKey, TMap$1 as TMap, TMessage, TModify, TNotificationMessage, TPropsComparator, TPropsConfiguration, TPropsSelector, TRequireOnlyOne, TShortcutBranch, TUpdateFieldConfiguration, Url, WithEventsValue, addBoundary, apiaDateToStandarFormat, arrayOrArray, autoDisconnectMutationObserver, cantFocusSelector, customEvents, dateToApiaFormat, debugDispatcher, decrypt, disableChildrenFocus, downloadUrl, enableChildrenFocus, enableDebugDispatcher, encrypt, findOffsetRelativeToScrollParent, findScrollContainer, focus, focusSelector, formatMessage, getDateFormat, getFocusSelector, getIndex, getLabel, getSpecificParent, getValueByPath, globalFocus, isChild, isDebugDispatcherEnabled, isPropsConfigurationObject, makeImperativeComponent, makeSingleImperativeComponent, noNaN, notificationsSelector, parseAsSize, parseXmlAsync, persistentStorage, propsStore, screenLocker, scrollParentIntoElement, setValueByPath, shortcutController, toBoolean, ucfirst, useCombinedRefs, useDebouncedCallback, useDebouncedState, useDomState, useImperativeComponentContext, useImperativeComponentEvents, useLatest, useLocalStorage, useMount, usePanAndZoom, usePrevious, usePropsSelector, useStateRef, useUnmount, useUpdateEffect };
+//# sourceMappingURL=index.d.ts.map