import { ReactNode, ForwardedRef } from 'react';
import { DraggableData } from 'react-draggable';
import { ContainerSize } from '../../utils/types';
import { Theme } from '@mui/material/styles';
import { DragResizeWindowRNDSlots } from './slots/slots';
import { COMPONENT_KEY_COMPONENT } from './constants';
import { ResizeCallbackData, ResizeHandle } from '../extended/React-Resizable';
import { ResizeDirection } from 're-resizable';
import { M4LOverridesStyleRules } from '../../@types/augmentations';
import { Props as RndProps } from 'react-rnd';
/**
 * Tipo que define la corrección de la posición
 * - nCorrection: Cantidad de corrección
 * - x: Coordenada x
 * - y: Coordenada y
 */
export type CorrectionPosition = {
    nCorrection: number;
    x: number;
    y: number;
};
/**
 * Tipo que representa la posición de la ventana (o cualquier otro elemento arrastrable/redimensionable).
 * - left: Coordenada x
 * - top: Coordenada y
 * - width: Ancho
 * - height: Alto
 */
export type Position = {
    x: number;
    y: number;
    width: number;
    height: number;
};
export interface CurrentState extends Position {
    /**
     * "dragging" indica la posición actual cuando se está moviendo el ventana
     */
    dragging?: {
        y: number;
        x: number;
        width: number;
        height: number;
    };
    /**
     * "resizing" indica el tamaño actual cuando se está redimensionando el ventana
     */
    resizing?: {
        x: number;
        y: number;
        width: number;
        height: number;
        handle: ResizeDirection;
        widthInitial: number;
        heightInitial: number;
    };
    /**
     * Posición inicial antes de comenzar el dragging o resizing
     */
    initialPosition?: Position;
    /**
     * "shrinkLeftAt" Indica en que valor estaba el left antes de compactar padre en un resize
     */
    shrinkLeftAt?: number;
    /**
     * "shrinkTopAt" Indica en que valor estaba el top antes de compactar padre en un resize
     */
    shrinkTopAt?: number;
    /**
     * "overflowWidthAt" Indica en que valor estaba el width antes de compactar padre en un resize
     */
    overflowWidthAt?: number;
    /**
     * "overflowHeightAt" Indica en que valor estaba el Height antes de compactar padre en un resize
     */
    overflowHeightAt?: number;
    /**
     * "minConstraints" Indica los límites mínimos de la ventana
     */
    minConstraints?: [number, number];
    /**
     * "magnetizeBottom" Indica si se debe magnetizar la ventana a la top ante un resize, conserve el mismo top
     */
    magnetizeBottom?: boolean;
    /**
     * "magnetizeRight" Indica si se debe magnetizar la ventana a la derecha ante un resize, conserve el mismo rigth
     */
    magnetizeRight?: boolean;
}
/**
 * Representa una posición parcial, solo incluye las propiedades left y top.
 * - left: Coordenada x
 * - top: Coordenada y
 */
export type PartialPosition = {
    x: number;
    y: number;
};
/**
 * Tipo que define los límites de movimiento de la ventana arrastrable.
 */
export type DraggableWindowBounds = {
    left?: number;
    right?: number;
    top?: number;
    bottom?: number;
};
/**
 * Tipo de callback para el evento de redimensionamiento.
 */
export type ResizeCallback = ((e: React.SyntheticEvent, data: ResizeCallbackData) => any) | undefined;
/**
 * Tipo para el componente o la función que define el handle para redimensionar la ventana.
 */
export type ResizeHandleComponente = React.ReactNode | ((resizeHandle: ResizeHandle, ref: React.RefObject<any>) => React.ReactNode) | undefined;
/**
 * Parámetros relacionados con el tamaño del contenedor, usado en la posición y redimensionamiento.
 */
export type PositionParams = ContainerSize;
/**
 * Acción que se realiza en el contenedor (igual, encogiéndose o expandiéndose).
 */
export type ContainerAction = 'equals' | 'shrinking' | 'expanding';
/**
 * Referencia para el componente DragResizeWindow.
 */
export type DraggableWindowRefProps = {
    current: HTMLDivElement | null;
};
/**
 * Tipo que representa las posiciones predeterminadas (vertical y horizontal) de la ventana.
 */
export interface RNDDefaultPosition {
    vertical: {
        top: number;
        bottom: number;
    } | {
        top: number;
        height: number;
    } | {
        height: number;
    } | {
        bottom: number;
        height: number;
        magnetize?: boolean;
    } | {
        percent: number;
    };
    horizontal: {
        left: number;
        right: number;
    } | {
        left: number;
        width: number;
    } | {
        right: number;
        width: number;
        magnetize?: boolean;
    } | {
        percent: number;
    } | {
        width: number;
    };
}
export interface DragResizeWindowRNDRefHandler {
    ensureVisible: () => void;
    current: HTMLElement | null;
}
/**
 * Propiedades del componente DragResizeWindow, que incluye tanto los controles de arrastre como de redimensionamiento.
 */
export interface DragResizeWindowPropsRND extends Partial<Omit<RndProps, 'handle' | 'cancel'>> {
    children: ReactNode;
    /**
     * "className" permite identificar si es placeHolder y estilar
     */
    className?: string;
    /**
     * Inline-style object to pass to the root element.
     */
    style?: React.CSSProperties | undefined;
    /**
     * zIndex: Permite modificar en los ventanas freeMove (popups) el zIndex
     */
    zIndex?: number;
    /**
     * defaultPosition permite definir la posición inicial de la ventana
     * TODO: Debe también recibir anchorEl y anchorPosition y calcular la posición en base a este
     */
    defaultPosition?: RNDDefaultPosition;
    /**
     * "bounds" permite definir los limites de movimiento de la ventana
     */
    bounds?: DraggableWindowBounds;
    /**
     *
     * we should set scale coefficient to avoid render artifacts while dragging.
     */
    transformScale?: number | undefined;
    /**
     * "containerElement" contenedor padre
     */
    containerElement?: HTMLElement;
    /**
     * "containerSize" tamaño del contenedor padre
     */
    containerSize?: ContainerSize | undefined;
    /**
     * "draggable" permite definir si la ventana es "draggable" o no. Por defecto es "true
     */
    draggable?: boolean;
    /**
     * "handle" permite definir el elemento que se debe usar para arrastrar la ventana
     * Ejemplo: ".handle_title", default  `.${draggableWindowClasses.draggableHandle}`
     */
    draggableHandle?: string;
    /**
     * "cancel" permite definir el elemento que no se debe usar para arrastrar la ventana
     * Ejemplo: ".title_buttons"
     */
    draggableCancel?: string;
    /**
     * "resizable" permite definir si la ventana es "resizable" o no. Por defecto es "true
     */
    resizable?: boolean;
    /**
     * "hidden" permite definir si la ventana está oculta o no. Por defecto es "false"
     */
    hidden?: boolean;
    /**
     * "allowResizeContainer" permite definir si se puede redimensionar el contenedor padre
     */
    allowHeightResizeContainer?: boolean;
    /**
     * "allowWidthResizeContainer" permite definir si se puede redimensionar el contenedor padre
     */
    allowWidthResizeContainer?: boolean;
    /**
     * "windowRef" permite definir una referencia a la ventana
     */
    windowRef?: ForwardedRef<HTMLDivElement | undefined>;
    /**
     * Min width (alias used by parents; not forwarded to DOM)
     */
    minWindowWidth?: number;
    /**
     * Min height (alias used by parents; not forwarded to DOM)
     */
    minWindowHeight?: number;
    /**
     * Resize handles exposed by the shared shell. They are translated into the
     * `react-rnd` `enableResizing` edge map while preserving the default
     * all-handles behavior when omitted.
     */
    resizeHandles?: ResizeHandle[] | readonly ResizeHandle[];
}
/**
 * Referencia del estado del componente DragResizeWindow.
 */
export interface StateRef extends Pick<DragResizeWindowPropsRND, 'bounds'>, CurrentState {
    data?: DraggableData;
    /**
     * containerSize: Tamaño del contenedor padre la ultima vez que se actualizó
     */
    containerSize?: ContainerSize | undefined;
    /**
     * isAbove: Indica si el cursor esta por encima del contenedor padre and se esta arrastrando hacia arriba
     */
    isAbove?: boolean;
    /**
     * lastScrollTop: Valor del scroll del contenedor padre la ultima vez que se actualizó
     */
    lastScrollTop?: number;
    /**
     * lastScrollLeft: Valor del scroll del contenedor padre la ultima vez que se actualizó
     */
    lastScrollLeft?: number;
    /**
     * resizeByScroll: Indica si el resize se esta haciendo por scroll o el eventHandler del resize
     */
    resizeByScroll?: boolean;
}
/**
 * Tipos para los slots del componente DragResizeWindow.
 */
export type DragResizeWindowRNDSlotsType = keyof typeof DragResizeWindowRNDSlots;
/**
 * Propiedades del estado propietario del componente DragResizeWindow.
 */
export type DragResizeWindowOwnerState = {
    /**
     * "dragging" indica la posición actual cuando se está moviendo el ventana
     */
    dragging?: boolean;
    /**
     * "resizing" indica el tamaño actual cuando se está redimensionando el ventana
     */
    resizing?: boolean;
    /**
     * "draggingActive" indica si la ventana está activa
     */
    draggingActive?: boolean;
    /**
     * "hidden" permite definir si la ventana está oculta o no. Por defecto es "false
     */
    hidden?: boolean;
    /**
     * "x" indica la posición x de la ventana
     */
    x?: number;
    /**
     * "y" indica la posición y de la ventana
     */
    y?: number;
};
/**
 * Tipo de reglas de estilo para el componente DragResizeWindow.
 */
export type DragResizeWindowRNDStyles = M4LOverridesStyleRules<DragResizeWindowRNDSlotsType, typeof COMPONENT_KEY_COMPONENT, Theme>;
//# sourceMappingURL=types.d.ts.map