import { GetLabelType, NetworkProps } from '@m4l/core';
import { ReactNode } from 'react';
import { CookieType, EmmitNewModalProps, EmmitNewPopupProps, EmmitNewWindowProps, AreaWindowProps, EmmitNewLayoutProps } from '../../types';
import { DebouncedFunc } from 'lodash';
import { LayoutItem } from '../../../GridLayout';
import { ContainerChangeEvent } from '../../../GridLayout/subcomponents/Responsive/types';
import { Layout, Breakpoint, Layouts } from '../../../GridLayout/types';
import { PopupsProviderStoreStateWithActions } from '../../../popups/components/PopupsProvider/contexts/PopupsContext/types';
import { ModuleAction, WinType } from '../../../WindowBase/types';
export type WinLayoutItem = LayoutItem & {
    winType: WinType;
};
export type Breakpoints = {
    [P: string]: number;
};
export type Cols = {
    [P: string]: number;
};
export type ViewAreaMode = 'multiple' | 'single';
export type AreaStatus = 'init' | 'loading' | 'load' | 'loaded' | 'error';
export interface Area {
    /**
     *  "id" Id del area de trabajo
     */
    id: string;
    /**
     *  "name" Nombre del area de trabajo
     */
    name: string;
    /**
     *  "status" Estado del area de trabajo
     */
    status: AreaStatus;
    /**
     *  "zPopUpIndex" Indice de la ventana emergente
     *  @deprecated El indice ya es manejado por el PopupsProvider
     */
    zPopUpIndex: number;
    /**
     * Indica si se deben cargar las ventanas de la area de trabajo, por defecto cuando se agrega una area,
     * no se cargan las ventanas, ya que no hay, pero cuando se abre un area, se cargan las ventanas.
     */
    loadWindows: boolean;
    /**
     * "containerHeight" Altura del contendor de area, se deja en cada área porque solo llegan en eventos de resize cuando está diferente a display "none"
     * Este valor se actualiza en el evento "onContainerChange" que emite el componente ResponsiveGridLayout
     * Es necesario para poder calcular el tamaño de las ventanas nuevas que se agregan al area.
     */
    containerHeight?: number;
    /**
     * "currentBreakpoint" Breakpoint actual del area de trabajo
     */
    currentBreakpoint?: Breakpoint;
    /**
     * "layouts" Layouts del area de trabajo
     */
    layouts: Layouts;
    /**
     * "maximizedId" Id de la ventana que está maximizada, si es undefined, no hay ninguna ventana maximizada
     */
    maximizedId?: string | undefined;
    /**
     * Son los ids de las ventanas, en el orden en que se agregaron
     */
    layoutItemsIds: string[];
    /**
     * "currentLayoutId" Id de la ventana actual seleccionada
     */
    currentLayoutId: string;
    /**
     * "breakpoints" Breakpoints del area de trabajo, se usa para el responsive son los pixeles que representan cada breakpoint
     */
    breakpoints: Breakpoints;
    /**
     * "cols" numero de columnas por cada breakpoint
     */
    cols: Cols;
}
/**
 * estado de carga de las areaS de trabajo.
 */
export type AreasStatus = 'init' | 'loading' | 'loaded' | 'error';
export type OwnerState = {
    /**
     *  "isSkeleton" indica si el componente está en skeleton.
     */
    status: AreasStatus;
    /**
     * "readyForHooks" indica si el componente ejecutó el efecto de carga y se suscrubió al eventemitter. Utilizado normalmente en storybook
     */
    readyForHooks: boolean;
};
/**
 * Estados que se actulizan por fuera del store, a través de hooks
 */
export type ExternalOwnerState = Pick<OwnerState, 'readyForHooks'>;
/**
 * Interface que define el estado del componente (variables y funciones )
 */
export interface AreasStoreState {
    /**
     *  "storeId" Id del store
     */
    storeId?: string;
    /**
     *  "loadAreasFromNetwork" Indica si se deben cargar/grabar las áreas de trabajo en la API
     */
    loadAreasFromNetwork: boolean;
    /**
     *  "loadCookiesFromNetwork" Indica si se deben cargar/grabar las cookies en la API
     */
    loadCookiesFromNetwork: boolean;
    /**
     *  "currentAreaId" Area de trabajo seleccionada
     */
    currentAreaId: string;
    /**
     *  "currentModuleId" Módulo seleccionado
     */
    currentModuleId: string;
    /**
     *  "ownerState" enfocado al funcionamiento de las clases
     */
    ownerState: OwnerState;
    /**
     *  "windowsModalsIds" id de ventans modales abiertas, en el orden en que se agregaron
     */
    windowsModalsIds: string[];
    /**
     *  "areasIds" Areas de trabajo para saber en que orden se muestran en el AreasAdmin
     */
    areasIds: string[];
    /**
     *  "hashAreas" Areas de trabajo
     */
    hashAreas: Record<string, Area>;
    /**
     *  "hashWindows" Todas las ventanas de todas las áreas cagadas, incluyendo layouts, popups y modals
     */
    hashWindows: Record<string, AreaWindowProps>;
    /**
     *  "networkOperation" funcion que usará el Store para enviar las peticiones de red
     */
    networkOperation: (props: NetworkProps) => Promise<any>;
    /**
     *  "getLabel" funcion que usará para traducir las etiquetas de diccionario, cuando se agrega una nueva area, se requier tener acceso al diccionario
     */
    getLabel: GetLabelType;
    /**
     * Como desde zustand no se puede acceder a meotodos de un contexto de react, se deben proporcionar en el momento de creación.
     */
    popupsProviderMethods: {
        addPopup: PopupsProviderStoreStateWithActions['popupsActions']['addPopup'];
        removePopup: PopupsProviderStoreStateWithActions['popupsActions']['removePopup'];
        removePopupsByGroupId: PopupsProviderStoreStateWithActions['popupsActions']['closePopupsByGroupId'];
        bringPopupOnFront: PopupsProviderStoreStateWithActions['popupsActions']['bringPopupOnFront'];
        closeAllPopupsByParentId: PopupsProviderStoreStateWithActions['popupsActions']['closeAllPopupsByParentId'];
        setSelectedPopupId: PopupsProviderStoreStateWithActions['popupsActions']['setSelectedPopupId'];
    };
}
export interface AreasStoreStateWithActions extends AreasStoreState {
    areasActions: {
        /**
         * inicializa el store cargando las áreas de trabajo.
         * Una vez termina el proceso, actualiza el estado de carga (ownerState?.status) a "loaded".
         * Normalmente es asyncrono en producción por el llamado al endpoint áreas.
         */
        init: () => void;
        /**
         * Arega un area de trabajo y la selecciona. Adiconalmente limpia el currentModuleId
         * Si esta habilitado "loadAreasFromNetwork" invoca al endpoint de POST de areas
         * @returns id del ara de trabajo
         */
        addArea: () => string;
        /**
         * Edita el nombre del área de trabajo.
         * Si está habilitado y sincroniza los cambios en la API.
         * @returns nombre del area de trabajo
         */
        editArea: (idArea: string, newName: string) => void;
        /**
         * Selecciona el area y adicionalmente notifica si el camnbio de modulo para que
         * Actualiza el currentModuleId por el layout seleccionado que tenga el area actualmente.
         * Con el fin de poder lanzar el cambio de módulo y se vea reflejado en el menu.
         * Carga adicionalmente las ventanas cuando se seleccione por primera vez si eestá habilitado el uso de API (loadAreasFromNetwork)
         * @param newAreaId Id de area a seleccionar
         * @returns
         */
        selectArea: (newAreaId: string) => void;
        /**
         * Borra un area de trabajo, si esta activa "loadAreasFromNetwork" llama a la API.
         * @param areaId Id de area a borrar
         * @returns void
         */
        deleteArea: (areaId: string) => void;
        /**
         * Actualiza la variable de estado "getLabel"
         * @param newHandler handle o función que va a traducir las etiquetas, esto es necesario debido que getLabel de useModuleDictionary
         * cambia por el useCallback, cuando el diccionario se carga.
         * @returns void
         */
        setHandlerGetLabel: (newHandler: GetLabelType) => void;
        /**
         * Modifica los estados que se actualizan externamente al Store
         * @param newIsMobile
         * @returns
         */
        setExternalState: (newExternalState: Partial<ExternalOwnerState>) => void;
    };
    areaActions: {
        /**
         * Agrega una ventana aca se deriva de acuerdo al emergeType si va para popup, modal o layout
         */
        addWindow: (newWindow: EmmitNewWindowProps) => void;
        /**
         * Agrega un layout al AreaGridLayout
         */
        addLayout: (areaId: string, windowId: string, newWindow: EmmitNewLayoutProps) => void;
        /**
         * Cierra un layout y lo retira del AreaGridLayout
         */
        closeLayout: (areaId: string, removePopUpId: string) => void;
        /**
         * Selecciona un layout, para marcarlo como el layout actual
         */
        selectLayout: (areaId: string, layoutId: string, saveCookie?: boolean) => void;
        /**
         * Colapsa un layout, para que se vea solo la barra de titulo
         */
        colapseLayoutItem: (areaId: string, layoutId: string) => void;
        /**
         * Descolapsa un layout, para que se vea el layout completo
         */
        unColapseLayoutItem: (areaId: string, layoutId: string) => void;
        /**
         * Normaliza los layouts, remueve el maximizado
         * TODO: Revisar como debe interactuar con popups
         */
        normalizeLayouts: (areaId: string) => void;
        /**
         * Maximiza un layout, establece el maximizedId del area
         */
        maximizeLayout: (areaId: string, layoutId?: string) => void;
        /**
         * Guarda los layouts en la API
         */
        saveLayouts: (areaId: string) => void;
        /**
         * Actualiza los layouts en el AreaGridLayout cuando se redimensiona la ventana del navegador
         * siempre y cuando no este maximizada una ventana
         */
        onBreakpointsLayoutsChange: (areaId: string, currentLayout: Layout, newAllLayouts: Layouts) => void;
        /**
         * Agrega un popup al PopupsProvider
         */
        addPopup: (areaId: string, windowId: string, newWindowProps: EmmitNewPopupProps) => void;
        /**
         * Se remueve de hashWindows y se envia a PopupsProvider que cierr el popup
         * TODO: Reivisar si funciona bien
         */
        closePopup: (areaId: string, removePopupId: string) => void;
        /**
         * Agrega un modal a hashWindows y windowsModalsIds
         */
        addWindowModal: (areaId: string, windowId: string, newWindowModalProps: EmmitNewModalProps) => void;
        /**
         * Se remueve de hashWindows, y lo remueve de windowsModalsIds
         */
        closeWindowModal: (removeModalId: string) => void;
        /**
         * Actualiza el estado de la ventana cuando cambia el tamaño de la ventana del navegador
         */
        onContainerChange: (areaId: string, e: ContainerChangeEvent) => void;
        /**
         * Guarda los layouts en la API con bounced
         */
        bouncedSaveBreakpointsLayouts: DebouncedFunc<(areaId: string) => void>;
        /**
         * Carga las ventanas de la API cuando se selecciona una area por primera vez
         */
        loadWindowsFromApi: (areaId: string) => void;
    };
    windowActions: {
        setActions: (windowId: string, newActions: ModuleAction[], version?: string, buildTime?: string) => void;
        getCookie: (windowId: string, id: string) => Record<string, any> | undefined;
        getCookies: (windowId: string, type: CookieType) => Record<string, any>;
        setCookie: (windowId: string, id: string, type: CookieType, cookie: Record<string, any>) => void;
        close: (windowId: string, useFnQueryClose?: boolean) => void;
        startProgress: (windowId: string) => void;
        stopProgress: (windowId: string) => void;
        loadCookiesFromApi: (windowId: string) => void;
        saveModuleCookies: (windowId: string) => void;
        resetModuleCookies: (windowId: string) => void;
        setFnQueryClose: (windowId: string, fnQueryClose: () => void) => void;
        setWindowTitle: (windowId: string, title: string) => void;
        setWindowSubTitle: (windowId: string, subTitle: string) => void;
        setWindowEditionInfo: (windowId: string, editionInfo: string) => void;
    };
}
export type DefaultAreasStoreProps = Omit<AreasStoreState, 'currentArea'>;
export type InitialAreasStoreProps = Pick<AreasStoreState, 'networkOperation' | 'loadAreasFromNetwork' | 'loadCookiesFromNetwork' | 'getLabel' | 'ownerState' | 'popupsProviderMethods' | 'storeId'> & Partial<DefaultAreasStoreProps>;
export interface AreasProviderProps {
    /**
     *  "storeId" identificador del store
     */
    storeId?: string;
    /**
     *  "storeDevtoolsEnabled" determina si se debe usar devtools para el store
     */
    storeDevtoolsEnabled?: boolean;
    children: ReactNode;
    loadAreasFromNetwork: boolean;
    loadCookiesFromNetwork: boolean;
    onSelectLayout?: (moduleId: string) => void;
    onLoad?: () => void;
}
//# sourceMappingURL=types.d.ts.map