import { DynamicMFParameters } from '../WindowBase/contexts/DynamicMFParmsContext/types';
import { DynamicMFStore } from '../WindowBase/contexts/DynamicMFParmsContext/store';
import { LayoutItem } from '../GridLayout';
import { MFBaseProps } from '../MFLoader/types';
import { ModuleAction } from '../WindowBase';
import { PopupAddProps } from '../popups/components/PopupsProvider/contexts/PopupsContext/types';
import { DragResizeWindowPropsRND } from '../DragResizeWindowRND/types';
import { JSX_REACT_NODE, WindowOptions, WinType } from '../WindowBase/types';
/**
 * Tipo que representa el tipo de emergencia de la ventana: diseño, popup o modal.
 */
export type EmergeType = 'layout' | 'popup' | 'modal';
/**
 * Tipo que representa el tipo de apertura de la ventana: normal o maximizado.
 */
export type OpenType = 'normal' | 'maximized';
/**
 * Tipo que representa el tipo de cookie: ventana o módulo.
 */
export type CookieType = 'window' | 'module';
/**
 * Objeto que contiene las cookies de un módulo y de una ventana.
 */
export type Cookies = {
    moduleCookies: Record<string, any>;
    windowCookies: Record<string, any>;
};
/**
 * Tipo que representa el estado de la ventana: inicialización, carga, cargado o error.
 */
export type WindowStatus = 'init' | 'loading' | 'loaded' | 'error';
export type WindowState = {
    /**
     * status Indica el proceso de cargado de la ventana
     */
    status: WindowStatus;
    dynamicMFStore: DynamicMFStore;
    /**
     * loading indica si la barra de progress aparece o no
     */
    loading: boolean;
    /**
     * version del Microfrontend, esta version es actualizada normalmente por el ModuleLayout del microfrontend
     */
    version?: string;
    /**
     * buildTime del Microfrontend, esta buildTime es actualizada normalmente por el ModuleLayout del microfrontend
     */
    buildTime?: string;
    /**
     * Acciones del módulo.
     */
    moduleActions: ModuleAction[];
    /**
     * Cookies de la ventana.
     */
    cookies: Cookies;
    /**
     * "fnQueryClose"  función que reemplaza la opción de cerrado normal de la ventana, utilizado en Los MFs Add/Edit para confirmar la acción
     * @returns void
     */
    fnQueryClose?: () => void;
    /**
     * moduleCount representa el identificador de
     * la ventana cuando se repite un módulo en una misma área
     */
    moduleCount?: number;
};
/**
 * Propiedades base para cuando se crea una ventana en la aplicación. En terminos generales son las propiedas base del Emmit
 */
export interface EmmitNewWindowBase {
    /**
     * Tipo de emergencia de la ventana: diseño, popup o modal.
     */
    emergeType: EmergeType;
    /**
     * Tipo de ventana: microfrontend o componente.
     */
    winType: WinType;
    /**
     * Id del módulo. Este es el dado por el Backend
     */
    moduleId: string;
    /**
     * Parámetros dinámicos del módulo. Estos paramtros son lo que un modulo puede enviarle a otro modulo para comunicarse entre ellos.
     * Los parametros pueden ser datos tipo string, number, boolean, object, array, etc. y tambien pueden ser funciones.
     */
    dynamicParams: DynamicMFParameters;
    /**
     * Url del icono del módulo.
     */
    iconUrl: string;
    /**
     * Título de la ventana.
     */
    title: string;
    /**
     * Subtítulo de la ventana.
     */
    subTitle?: string;
    /**
     * Información de edición de la ventana.
     */
    editionInfo?: string;
    /**
     * Opciones de la ventana. Son acciones que permiten persistir las cookies de la ventana a nivel de módulo, para que aunque se cierre esta,
     * Cuando se abra de nuevo venga con las cookies guardadas.
     * TODO: Se daño con la migración de ventanas a WindowBase, se debe revisar
     */
    windowOptions?: WindowOptions;
    /**
     * Id del padre de la ventana.
     */
    parentId?: string;
    /**
     * Tipo de apertura de la ventana: normal o maximizado.
     */
    openType?: OpenType;
    /**
     * Id de la ventana que puede ser reemplazada. Esto permite avisarle a una ventana existente que debe repintar su contenido, en vez de lanzar una nueva ventana.
     */
    replaceMeId?: string;
}
/**
 * Propiedades base para una ventana en la aplicación. En terminos generales es lo que el store aporta en el metodo AddWindow
 */
export interface AreaWindowBaseProps extends EmmitNewWindowBase {
    areaId: string;
    windowId: string;
    onClose?: (windowId: string) => void;
    devCookies?: Cookies;
}
export interface AreaLayoutBaseProps extends AreaWindowBaseProps {
    emergeType: 'layout';
    layoutProps: Omit<LayoutItem, 'i'>;
}
export interface AreaLayoutMFProps extends AreaLayoutBaseProps {
    winType: 'microfrontend';
    mfProps: MFBaseProps;
}
export interface AreaLayoutComponentProps extends AreaLayoutBaseProps {
    winType: 'component';
    component: JSX_REACT_NODE;
}
export type AreaLayoutProps = AreaLayoutMFProps | AreaLayoutComponentProps;
export type AreaLayoutStateProps = AreaLayoutProps & WindowState;
export type EmmitNewLayoutProps = Omit<AreaLayoutMFProps, 'windowId' | 'onClose' | 'areaId'> | Omit<AreaLayoutComponentProps, 'windowId' | 'onClose' | 'areaId'> & {
    winType: string;
    emergeType: string;
    layoutProps: Omit<LayoutItem, 'i'>;
    moduleId: string;
    dynamicParams: Record<string, any>;
    iconUrl: string;
    title: string;
};
/**
 * Retirar la props que ya entran por el Emmit, y dejar solo las que ingresan directamente al Popup
 */
type PopupPropsForAdd = Partial<Pick<PopupAddProps, 'bounds' | 'defaultPosition' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight' | 'resizable' | 'draggable'>>;
export type Position = {
    x: number;
    y: number;
    width: number;
    height: number;
};
export interface AreaPopupBaseProps extends AreaWindowBaseProps {
    emergeType: 'popup';
    popupProps: PopupPropsForAdd;
    replaceMeId?: string;
}
export interface AreaPopupMFProps extends AreaPopupBaseProps {
    winType: 'microfrontend';
    mfProps: MFBaseProps;
}
export interface AreaPopupComponentProps extends AreaPopupBaseProps {
    winType: 'component';
    component: JSX_REACT_NODE;
}
export interface EmmitNewPopupMFProps extends EmmitNewWindowBase {
    emergeType: 'popup';
    winType: 'microfrontend';
    mfProps: MFBaseProps;
    popupProps: PopupPropsForAdd;
}
export interface EmmitNewPopupComponentProps extends EmmitNewWindowBase {
    emergeType: 'popup';
    winType: 'component';
    component: JSX_REACT_NODE;
    popupProps: PopupPropsForAdd;
}
export type EmmitNewPopupProps = EmmitNewPopupMFProps | EmmitNewPopupComponentProps;
export interface HashWindowsByLayouts {
    [P: string]: AreaLayoutStateProps;
}
type AreaModalPropsForAdd = Pick<DOMRect, 'width' | 'height'> & Pick<DragResizeWindowPropsRND, 'minWindowWidth' | 'minWindowHeight'>;
export interface AreaModalBaseProps extends AreaWindowBaseProps {
    emergeType: 'modal';
    zIndex?: number;
    modalProps: AreaModalPropsForAdd;
}
export interface AreaModalMFProps extends AreaModalBaseProps {
    winType: 'microfrontend';
    mfProps: MFBaseProps;
}
export interface AreaModalComponentProps extends AreaModalBaseProps {
    winType: 'component';
    component: JSX_REACT_NODE;
}
export type EmmitNewModalProps = Omit<AreaModalMFProps, 'windowId' | 'onClose' | 'areaId'> | Omit<AreaModalComponentProps, 'windowId' | 'onClose' | 'areaId'>;
export type AreaWindowProps = (AreaLayoutMFProps & WindowState) | (AreaLayoutComponentProps & WindowState) | (AreaPopupMFProps & WindowState) | (AreaPopupComponentProps & WindowState) | (AreaModalMFProps & WindowState) | (AreaModalComponentProps & WindowState);
export interface HashWindows {
    [P: string]: AreaWindowProps;
}
export type EmmitNewWindowProps = EmmitNewLayoutProps | EmmitNewPopupProps | EmmitNewModalProps;
export type AddWindow = (newWindow: EmmitNewWindowProps) => string;
export {};
//# sourceMappingURL=types.d.ts.map