import DockingCalculator from "../Docking/dockingMain";
import DockableWindow from "../Docking/dockableWindow";
import { MonitorDimensions } from "../Docking/types";
import { FinsembleWindowData } from "../../../common/FinsembleWindowData";
declare type WindowsData = {
    aspectRatio: number;
    top: number;
    bottom: number;
    left: number;
    right: number;
    dockableWindow: DockableWindow;
    windows?: WindowsData[];
    isGroup?: boolean;
    name?: string;
};
declare class AutoArrange {
    isArranged: object;
    DockingCalculator: DockingCalculator;
    constructor(params: any);
    /**
     *
     * For more, see {@link https://medium.com/@jtreitz/the-algorithm-for-a-perfectly-balanced-photo-gallery-914c94a5d8af#.c09v4fn1e}. This is a javascript port of a python solution to the linear partition problem.
     * @param {Array} aspectRatios An array of numbers; in this case, aspect ratios.
     * @param {Number} rows Number of rows to distribute aspectRatios across.
     * @returns {Array} ans Returns an array of arrays. Each internal array represents a row.
     * @private
     */
    linearPartition(aspectRatios: WindowsData[], rows: number): WindowsData[][];
    /**
     * @private
     * @param {LauncherClient~windowDescriptor} win
     * @param {monitorDimensions} monitorDimensions
     * @returns {boolean} Whether window is on the current monitor.
     */
    windowOnMonitor(windowDescriptor: any, monitorDimensions: any): boolean;
    /**
     * Takes a list of windows and returns only the ones that are subject to being auto-arranged
     *
     */
    getArrangableWindows(windowDescriptorList: FinsembleWindowData[]): FinsembleWindowData[];
    getWindowsOnMonitor(windowDescriptorList: FinsembleWindowData[], monitorDimensions: MonitorDimensions): WindowsData[];
    /**
     * Get windowData for all windows in the active workspace
     */
    getAllWindowsInActiveWorkspace(): Promise<FinsembleWindowData[]>;
    /**
     * Retrieves information about the passed in StackedWindow
     * @param {*} win
     */
    retrieveInformationForStackReconciliation(win: any): Promise<{
        stack: null;
        stackName: string;
    } | {
        stack: FinsembleWindowData | undefined;
        stackName: any;
    }>;
    /**
     * Given a window, if its a StackedWindow, this will search the monitor's auto arrange cache for any children of the stack
     * and replace the cache representation with the StackedWindow
     * @param {*} win
     */
    reconcileStackCreationWithAutoArrangedWindows(win: any): Promise<void>;
    /**
     * Given a window, if its a StackedWindow, this will search the monitor's auto arrange cache for the remaining window
     * in that stack and will replace the auto arrange cache with the remaining window
     * @param {*} win
     */
    reconcileStackDeletionWithAutoArrangedWindows(win: any): Promise<void>;
    /**
     * boxesToArrange is a concatenation of windows and groups built into singular objects
     * so they can be treated as 'boxes to rearrange' wrather than individual windows
     *
     * groupBoxes is an array of 'windows' that are actually a group of windows.
     * Built into a single object that looks like a 'window' by the arrangement code
     */
    private getBoxesToArrange;
    animateWindow(request: any): Promise<void>;
    /**
     * Arranges all windows in the current workspace that are visible on the current monitor. For more about the algorithm used to distribute windows across rows, see {@link https://medium.com/@jtreitz/the-algorithm-for-a-perfectly-balanced-photo-gallery-914c94a5d8af#.c09v4fn1e this post}. The algorithm chooses the number of rows by taking the square root of the number of windows on the monitor and rounding down. 3 windows results in 1 row. 4 windows results in 2 rows. 8 windows will be arranged across 2 rows. 9 windows will be arranged across 3 rows. Other breakpoints are 16, 25, and 36.
     * @param {Object} monitorDimensions Monitor dimensions of a given monitor. This value is passed
     * in from {@link util#getMonitorInfo}.
     */
    arrange(monitorDimensions: MonitorDimensions): Promise<void>;
    /**
     * Returns windows to where they were before an auto-arrange occurred.
     */
    revertArrangedWindows(monitorDimensions: any): void;
}
export default AutoArrange;
//# sourceMappingURL=autoArrange.d.ts.map