import DockableMonitor from "./dockableMonitor";
import DockableGroup from "./dockableGroup";
import DockableWindow from "./dockableWindow";
import { MonitorInfoDetail } from "../../../FEA";
import { Monitors } from "../../../common/Monitors";
import { SnappingRegions } from "./types";
import { DockingBounds, MoveRequest, SnapObject, ResizeObject, SnappedObject, BoundingBox, XYCoordinates } from "./types";
declare type Intersection = {
    stationaryRegion: string;
    movingRegion: any;
} | null;
export declare type GroupMode = {
    enabled: boolean;
    behavior?: "explicit";
    headerHeight?: number;
    groupTileBuffer?: number;
    allowSnappedWindowsToResize?: boolean;
    fillHolesOnUndock?: boolean;
    undockDisbandsEntireGroup?: boolean;
    requireRectangularityForGroupResize?: boolean;
};
/**
 *
 *
 * @returns
 */
declare abstract class DockingCalculator {
    groupAction: {
        name: null | string;
        windows: boolean[];
    };
    monitorsInstance: Monitors;
    groups: string[];
    resizeObject: ResizeObject;
    groupMode: GroupMode;
    groupMask: DockableWindow | null;
    moveRequest: MoveRequest | null;
    movingWindow: DockableWindow | null;
    bufferSize: number;
    resizeEventThrottlePeriod: number;
    moveCount: number;
    intersection: any;
    groupMaskQueue: any;
    groupMaskExpectedState: string;
    shiftKey: boolean;
    movingGroup: DockableGroup | null;
    groupMaskIsVisible: boolean;
    modalScrim: DockableWindow;
    movingAGroupOfWindows: boolean;
    abstract onMoveComplete(movedWin: {
        name: string;
        monitor: DockableMonitor;
    }, triggeredByAutoArrange: boolean): void;
    MINIMUM_HEIGHT: number;
    MINIMUM_WIDTH: number;
    groupTileBuffer: number;
    headerHeight: number;
    enableWindowsAeroSnap: boolean;
    constructor(monitorsInstance: Monitors);
    updateGroupData(): void;
    setBoundsErrorCB(err: any): void;
    removeUserRequestFromGroup(userRequest: any): void;
    /**
     * 5/20/19 Joe: Previously group was not set sometimes. In the event that the maximize request comes
     * into a window that is a group, this will throw an error.
     */
    ensureMovingGroupIsSet(moveRequest: any): void;
    ensureNotOffMonitor(movingWindow: DockableWindow): void;
    endMovingGroup(group: DockableGroup): void;
    maybeMakeOrBreakGroups(systemMoved: boolean): void;
    stopMovingGroup(group: DockableGroup): void;
    maybeDockWindow(moveRequest: any, movingWindow: DockableWindow, monitor: DockableMonitor): void;
    ensureNotInTwoGroups(win: DockableWindow, group: DockableGroup): void;
    /** **************************************
     * Core Loop
     * Docking works like this:
     * A dockableWindow receives a `bounds-change-request` event from the window object that it wraps (e.g., an Electron window). Then the docking calculator gets to work.
     * 1. `this.requestMove`.
     * 2. `this.onMouseDown`.
     * 3. `this.onMouseMove`.
     *
     * As the user moves her mouse around, steps 1 and 3 are executed.When she releases her mouse, the dockableWindow throws a `bounds-changed` event, which in turn calls `this.onMouseUp`.
     * The general idea is that the user says "Hey, I'd like to move my window 10px to the right of this window. The calculator spins through, notices that the window that the user is moving is within a snapping buffer around the other window. So it responds, "You're too close to that window, sorry, but we're snapping you.". If the movingWindow isn't within the stationaryWindow's buffer, we give the window the all clear to proceed.
     *************************************** */
    /**
     * This is the core controller of the program. It routes the window's moveRequest to the appropriate place, and it receives the modified bounds afterwards. It communicates the modified bounds to the window via the CB.
     * @param  {moveRequest} Request from the `dockableWindow`.
     * @param  {function} cb What to do after the window's new bounds have been calculated.
     */
    requestMove(userRequest: any, cb?: (result: any) => void): Promise<any>;
    /**
     * Windows can be part of two groups - one that can move, and one that allows shared border resizing/group resizing. When N windows are snapped together but not explicitly grouped together, they form an "immobileGroup". A movable group is one that the user has explicitly formed. This function returns the appropriate group, given a moveRequest.
     * @param {object} moveRequest moverequest.
     */
    getMovingGroup(moveRequest: any): DockableGroup | null;
    /**
     * Loops through all DockableGroups and reconstitutes gaps. This is to clean up an issue where
     * grouped windows containing a single pixel gap would break on mouse down as the system would
     * no longer consider them snapped, and therefore would break and remove the group
     */
    fixAllGroupGaps(): void;
    /**
     * Given a group, will clean up the gaps and reconstitute the groups
     * @param {object} group An object containing groups, with groupName as key
     */
    cleanupGroupGaps(group: any): void;
    /**
     * This function caches information in the resizeObject so that it doesn't need to be calculated onMouseMove.
     */
    onMouseDown(moveRequest: any): void;
    hideGroupMask(cb?: Function): void;
    /**
     * Transparency breaks often with group mask. So use this to show it.
     *
     * @param {any} bounds
     * @param {number} [opacity=0.5]
     * @param {any} [cb=Function.prototype]
     * @memberof DockingCalculator
     */
    showGroupMask(params: any, cb?: Function): any;
    /**
     * Show the modal scrim
     *
     * @memberof DockingCalculator
     */
    showModalScrim(params: any, cb?: Function): void;
    hideModalScrim(): void;
    /**
     * This function happens _after_ the calculations have been made. The request comes in, `this.requestMove` routes the request to the appropriate place, and modified bounds are passed into this function. It's a choke point for all docking-sanctioned window movement.
     */
    onMouseMove(bounds: any, cb: any): void;
    /**
     * When the user lifts her mouse, this is fired. It cleans up opacity, shows windows if we were moving a group, and cleans up global variables.
     *
     * @param {} params - Optional. Possible parameters:
     *									systemMoved: If true, indicates the OS initiated the group move
     *									triggeredByAutoArrange: If true, indicate the move was initiated by auto-arrange
     */
    onMouseUp(params?: any): Promise<void>;
    static get NO_CHANGE(): number;
    /** **************************************
     *	  Calculators - Window Collections 	*
     *************************************** */
    formGroup(name: any, params: any): string[];
    /**
     * Spins through all of the windows that can group and creates groups based on window position.
     */
    constituteGroups(): void;
    /**
     * Given a moveRequest, it returns an array of windowNames. The check essentially boils down to "is this window within my snapping buffer?"
     * @param  {moveRequest} moveRequest
     */
    getSnappableWindows(moveRequest: any): string[];
    /**
     * Checks to see if the window is within the snapping region of any monitor.
     */
    getSnappableMonitors(moveRequest: any): string[];
    /**
     * Returns an object that describes the edges and corners that are shared between two windows.
     */
    getSnapObj(win1: DockableWindow, win2: DockableWindow): SnappedObject;
    /**
     * Snaps two windows..
     */
    snapTwoWindows(win1: DockableWindow, win2: DockableWindow): void;
    /**
     * Wipes all relationships between windows and recalculates them.
     */
    recalculateSnaps(): void;
    /**
     * Returns an array of `snapObject`s. Just name, shared edges, shared corners, and whether the window canGroup.
     * @param  {dockableWindow} win
     */
    buildSnapRelationships(win: any): never[];
    /**
     * Returns any window with a vertex on a segment.
     * @param  {segment} segment A line segment. An array with 2 points in it (start and end).
     * @return {type}
     */
    getWindowBoxesOnSegment(segment: BoundingBox): SnapObject[];
    windowsOnEdgeFromPool(win: DockableWindow, edge: string, includeCorners: boolean): {
        name: string;
        edge: string;
    }[];
    /**
     * Similar to getWindowBoxesOnSegment but you can pass in a string instead of a line segment.
     * @param  {dockableWindow} win
     * @param  {string} edge E.g., 'left', 'right', etc.
     * @return {array}
     */
    getWindowsOnEdge(win: DockableWindow, edge: string, includeCorners?: boolean): {
        name: string;
        edge: string;
    }[];
    /**
     * Returns a list of windows that straddle a given edge.
     *	+-----------+------------+
     *	|           |            |
     *	|           |            |
     *	|    A      |     B      |
     *	|           |            |
     *	+-----------+--+---------+
     *	|              |         |
     *	|    C         |   D     |
     *	|              |         |
     *	+--------------+---------+
     *
     * In the drawing above, B straddles the left edge of D and the right Edge of C.
     * @param  {dockableWindow} win
     * @param  {string} edge E.g., 'left', 'right', etc.
     */
    getStraddlers(win: any): {
        name: string;
        edge: string;
    }[];
    /**
     * Given an X, Y point, it returns a list of windows with that point on their boundingBox.
     * @param  {object} point
     * @return {array}
     */
    getWindowsAtPoint(point: XYCoordinates): string[];
    /**
     * Just a helper to say whether a window has an edge on the edge of the group.
     * @param  {dockableWindow} win
     * @param  {dockableGroup} group
     */
    windowIsOnExteriorEdgeOfGroup(win: any, group: any): boolean;
    /**
     * Lets the program know that shift is being held down. This is used when moving a window that's explicitly grouped (if assimilation is turned on). In that case, the window moves out of the group.
     */
    setShift(bool: boolean): void;
    /**
     * Returns an ordered Object. Sorts by Top, then Left.
     * @return {Object} Object where the keys are names of the window.
     */
    orderWindows(windowList: any, anchor: any): DockableWindow[];
    /** **************************************
     *			Getters/Setters				*
     *************************************** */
    /**
     * Registers the window with the calculator
     * @param  {string} name
     * @param  {dockableWindow} val
     */
    addWindowInternal(name: string, val: DockableWindow): void;
    /**
     * Virtually unsnaps a window from all other windows. This doesn't affect physical positioning. Only the relationships that Docking is a aware of.
     */
    wipeSnapRelationships(name: any): void;
    /**
     * Removes a window from all groups.
     */
    removeWindowFromAllGroups(win: any, deleteGroupsWithOneWindow?: boolean): void;
    /**
     * Unregisters the window.
     * @param  {string} name
     */
    removeWindowInternal(name: string, removeListeners?: boolean): void;
    /**
     * Returns an array of window names.
     */
    getWindowNames(): string[];
    /**
     * @return {dockingPool}
     */
    getWindows(): Record<string, DockableWindow>;
    getUnignoredWindows(): DockableWindow[];
    /**
     * Gets a window object by name.
     * @param  {type} name
     * @param  {type} throwError Usually we want to throw the error, but sometimes we use this function to filter (e.g., autoarrange).
     * @return {type}
     */
    getWindow(name: string, throwError?: boolean): DockableWindow;
    /**
     * returns the monitor that the window is on. If the left edge of the window is on two or more monitors, we calculate the monitor that houses the majority of the window.
     * @param {string} windowName
     */
    getMonitorForWindow(win: any): DockableMonitor;
    /**
     * Returns a monitor object.
     * @param {string} name name of monitor.
     */
    getMonitor(name: string): DockableMonitor;
    /**
     * Unregisters a monitor with the calculator.
     * @param  {type} name
     * @return {type}
     */
    removeMonitor(name: string): void;
    /**
     * @return {MonitorPoolSingleton}
     */
    getMonitors(): Record<string, DockableMonitor>;
    /**
     * Returns a list of 'rawMonitors' from the container. These are only available when they are actually passed into the DockableMonitor when its instantiated.
     */
    getRawMonitors(): MonitorInfoDetail[];
    /**
     * Returns the monitors in an array
     */
    getMonitorArray(): DockableMonitor[];
    /**
     *
     */
    removeAllMonitors(): void;
    /**
     * Sets the resize throttle period. This allows the system to drop events that occur too quickly.
     */
    setResizeThrottlePeriod(throttlePeriod: number): void;
    /**
     * Sets the opacity that windows take when entering another window's snapping region.
     */
    setSnappingOpacity(opacity: number): void;
    /**
     * At one point we weren't sure if we were going to allow groups to snap because of bugs. This is vestigial and should be removed at some point.
     */
    setAllowGroupsToSnap(bool: any): void;
    /**
     * Sets the size of the region around windows that will trigger a snap.
     */
    setBufferSize(buffer: any): void;
    /**
     * Will prevent a window from being added to groups.
     */
    addToGroupBlacklist(windowName: any): void;
    /**
     * Will allow a window previously blacklisted to be included in group operations.
     */
    removeFromGroupBlacklist(windowName: string): void;
    /**
     * Adds a group to the calculator.
     * @param  {type} group
     */
    addGroup(group: DockableGroup): void;
    /**
     * Removes a group from the calculator.
     * @param  {type} groupName
     * @param {Boolean} willReform Whether the group is going to be reformed. This will
     * tell removeWindowFromGroup if it should modify window taskbar icon visibility.
     */
    removeGroup(groupName: string, willReform?: boolean): void;
    /**
     * Returns a list of groups that are capable of moving together.
     */
    getMovableGroups(): Record<string, DockableGroup>;
    /**
     * Returns the group Pool
     * @return {type}
     */
    getGroups(): Record<string, DockableGroup>;
    /**
     * Gets a group by name.
     * @param  {type} name
     * @return {type}
     */
    getGroup(name: string): DockableGroup;
    /**
     * Gets an array of group names.
     * @return {type}
     */
    getGroupNames(): string[];
    /**
     * Imagine 3 windows snapped horizontally. All are grouped ([A][B][C]). You ungroup B. This function will remove A and C. It iterates through all of the windows in the group and makes sure it's still attached to the group.
     */
    checkGroupMembership(win: any): void;
    /**
     * Removes a window from a group. When tiling, we do not delete groups with only one window. We could be doing an operation on a group with two windows, and we want to retain group membership so that hole-filling works appropriately.
     */
    removeWindowFromGroup(windowName: string, groupName: string, deleteGroupsWithOneWindow?: boolean, updateAOT?: boolean): void;
    /**
     * Single entry point for changing the taskbar icon's visibility.
     * At present, taskbar icon status is only changed when a window leaves or joins a movable group.
     */
    setTaskbarIconVisiblityForWindow(params: any): void;
    /**
     * Groups n-Windows.
     *
     * @param {any} params
     * @param {any} cb
     */
    groupWindows(params: any, cb?: any): void;
    /**
     * Given a group, this method will make sure only one window (the top right window) has a visible taskbar icon.
     * This method is called whenever a window is added to or removed from a group.
     * @param {DockableGroup} group
     */
    setTaskbarIconForGroup(group: DockableGroup): void;
    /**
     * @param  {type} groupName
     * @param  {dockableWindow} win
     */
    addWindowToGroup(params: {
        groupName: string;
        win: DockableWindow;
        ungroupedAlwaysOnTopState?: Record<string, boolean>;
        isMovable?: boolean;
        isAlwaysOnTop?: boolean;
        handleIcons?: boolean;
    }, cb?: any): DockableGroup | undefined;
    /**
     * Checks if windows in a group are on monitor. If not move the group on monitor so at least one window in the group
     * is fully on monitor.
     * Currently this is used on spawn to handle monitor changes when Finsemble wasn't running or a different workspace was loaded.
     * @param {*} name
     */
    checkAndFixGroupPosition(name: string): Promise<void>;
    /**
     * Vestigial function; used to pop a window out of a group. Can likely be removed in the future.
     */
    ejectWindow(name: string): void;
    /**
     * @return {boolean}
     */
    getGroupMode(): GroupMode;
    /**
     * @param  {object} groupMade
     * @param  {boolean} groupMade.enabled Whether group mode is enabled.
     * @param  {number} groupMode.headerHeight How large the header is in windows. This shouldn't be in this config. So bad.
     * @param  {number} groupMode.groupTileBuffer How large the buffer is on the edge of a group to trigger a group-tile operation.
     * @param  {boolean} groupMode.allowSnappedWindowsToResize Whether snapped windows will resize as a group.
     * @param  {boolean} groupMode.fillHolesOnUndock Whether leaving a group triggers a hole-filling operation
     * @param  {boolean} groupMode.undockDisbandsEntireGroup Whether clicking the undock button on one window will disband the entire group.
     * @param  {boolean} groupMode.requireRectangularityForGroupResize Whether a group must be a rectangle to scale the individual windows as a unit.
     */
    setGroupMode(groupMode: GroupMode): void;
    /**
     * Adds useful properties to a raw request.
     * @param  {moveRequest} req
     * @return {moveRequest}
     */
    setMoveRequest(req: any, win?: any): any;
    /**
     * @param  {dockableWindow} win
     */
    setStationaryWindow(win: any): void;
    /**
     * @param  {dockableWindow} win
     */
    setMovingWindow(win: any): void;
    /**
     * Convenience function I used for like 2 minutes.
     * @param  {dockableWindow} stationary
     * @param  {dockableWindow} moving
     */
    setWindows(stationary: any, moving: any): void;
    /** **************************************************
     *													*
     *		Calculators - Multiple Positions/Sizes		*
     *													*
     *************************************************** */
    /**
     * when a non-docking movement is made, we don't grab the bounds changing events.
     * So this updates everything. Example: auto-arrange.
     */
    updateWindowPositions(): void;
    /**
     * Returns the movableGroup for a window.
     */
    getMovableGroup(windowName: string): DockableGroup | null;
    /**
     * Returns the immobile group for a window. This is one where it is snapped to other windows, but not explicitly grouped by the user.
     */
    getImmobileGroup(windowName: string): DockableGroup | null;
    /**
     * Basically just code flow controller. Figures out whether the move will affect just a couple, a single window, or all windows in the group.
     * @param  {moveRequest} moveRequest
     * @param  {function} cb
     */
    handleGroup(moveRequest: any, cb: any): void;
    /**
     * Kills any gaps that may have happened after scaling a group proportionately.
     */
    eliminateGaps(): void;
    /**
     * Helper function for snapWindow
     */
    getIntersection({ request, stationaryWindow, region, stationaryBoundingBoxes, movingBoundingBoxes, }: {
        request: any;
        stationaryWindow: DockableWindow;
        region: string;
        stationaryBoundingBoxes: SnappingRegions;
        movingBoundingBoxes: any;
    }): Intersection;
    /**
     * Helper function for snapWindow
     */
    processIntersection(request: any, stationaryWindow: DockableWindow, intersection: any): {
        updatedRequest: any;
        match: boolean;
    };
    /** **************************************************
     *													*
     *	Calculators - Individual Window Position/Size	*
     *													*
     *************************************************** */
    /**
     * Returns a modified moveRequest. If the code gets here, it's because the moving window was inside of the stationary window's buffer, and a snap needed to occur.
     * @param  {moveRequest} request
     * @return {moveRequest}
     */
    snapWindow(request: any): any;
    /**
     * When moving a window, we don't want to add it to a group until all the calculations are complete. If two windows snap, this function is called. It figures out which group that the windows should form. Note: It always forms an immobile group (one that allows shared-border resizing). This is because a snap is not an explicit group.
     */
    getDeferredGroupAction(stationaryWin: any, movingWin: any): {
        name: string | null;
        windows: boolean[];
    };
    /**
     * Calculates resize bounds.
     * @param  {object} params
     * @return {moveRequest}
     */
    adjustSize(params: any): any;
    /**
     * Checks to see if a window has gotten too narrow, or too short.
     */
    checkShortCircuitsWithEdge(request: any, edge: any): any;
    /**
     * Checks to see if a request is allowed. Are you trying to make my window -20px? or 10px? Get out of here.
     */
    checkShortCircuits(request: any, win?: any): any;
    /**
     * Use when a window is moving and needs to be snapped. Width/Height aren't modified like in `this.adjustSize`.
     * @param  {type} params
     * @return {type}
     */
    getNewCoordinates(params: any): any;
    /**
     * Helper to return an object that says which edges are moving.
     * @function this.getMovingEdgesFromResizeHandle
     * @param  {type} handle
     * @return {type}
     */
    getMovingEdgesFromResizeHandle(handle: any): {
        top: boolean;
        right: boolean;
        left: boolean;
        bottom: boolean;
    };
    /**
     * Bounds are calculated in maskBoundsCalculator.js
     */
    moveGroupMask(): void;
    /**
     * NOT CURRENTLY USED.
     * Will be like `onMouseMove`, but for groups. Goal is to only move all grouped windows `onMouseUp`. In the interim, just move the mask around. Right now I move every window on every resizeEvent
     */
    _moveGroupMaskOld(): void;
    /**
     * This returns an object with all of the bounds of all of the windows in a given group. This should be moved in to the dockableGroup.
     */
    getBoundsOfGroupWindows(group: any): {};
    /**
     * For a group, it will iterate through its windows and set bounds on each of them.
     */
    setBoundsOfGroupWindows(group: DockableGroup, windowBounds: any, stopMove?: boolean): void;
    /**
     * Exports an array of bounds for the windows that are currently being managed by docking. This makes it easy to generate oddball test cases.
     */
    export(): string;
    /**
     * Cleans up shared edges of windows in a group
     * @param {*} group The group to operate on
     * @param {*} windowBounds An object containing bounds key'ed by window name
     * @param {*} triggeredByAutoArrange Wether or not this cleanup was trigger by auto arrange (if true will fire stopMove())
     */
    cleanupSharedEdges(group: DockableGroup, windowBounds: any, triggeredByAutoArrange?: boolean): any;
    /**
     * Run after everything, it removes any gaps that might have occurred (e.g., from fractional pixels, rounding, etc). It needs better inline documentation.
     */
    cleanupGaps(group: DockableGroup, windowBounds: any): any;
    shouldShortCircuit(request: any): {
        width: boolean;
        height: boolean;
    };
    private recurse;
    private recurseCorner;
    private maybeSnapToOtherWindows;
    private moveInteriorWindows;
    /**
     * Resizes a window or group of windows on the interior of a group
     * @param {moveRequest} moveRequest
     */
    resizeInteriorWindow(moveRequest: any): void;
    /**
     * function for debugging a 3x3 grid.
     */
    logger(): void;
    /**
     * Helper to determine whether a moveRequest will affect a window, the group, or just a local collection of windows that are snapped to the movingWindow.
     */
    shouldScaleGroup(moveRequest: MoveRequest): boolean;
    /**
     * Helper to determine whether a moveRequest will affect a window, the group, or just a local collection of windows that are snapped to the movingWindow.
     */
    shouldMoveAffectGroup(moveRequest: MoveRequest): boolean;
    /**
     * Should use this. Computes the difference between two boundsObjects.
     * @param {moveRequest} newBounds
     * @param {moveRequest} old
     */
    getBoundsDelta(newBounds: any, old: any): DockingBounds;
    /**
     * Will move a group of windows.
     * @param  {moveRequest} moveRequest
     * @param  {function} cb
     */
    handleGroupMove(moveRequest: any, cb: any): void;
    /**
     * Calculates the % change that a moveRequest inflicts on a group of windows.
     * @param  {moveRequest} moveRequest
     * @return {type}
     */
    getGroupDelta(groupName: string, moveRequest: any): {
        height: number;
        width: number;
    };
    /**
     * Creates the resizeObject. Put anything here that should be cached onMouseDown. Will be cleared onMouseUp.
     * @param {moveRequest} moveRequest
     * @return {resizeObject}
     */
    constructResizeObject(moveRequest: any): ResizeObject;
    /**
     * If a corner of a window is on the edge of the group, but it's not an actual corner, we need to treat that as an edge resize. See inline documentation for more. This is basically correcting errant resize-handles.
     * @note this behavior is locked behind `requireRectangularityForGroupResize`. Without that flag turned on, there's no need to change the resize handle.
     */
    correctResizeObject(win: any, resizeObject: ResizeObject): ResizeObject;
    /**
     * Resizes a window based on some delta.
     * @param  {dockableWindow} win
     * @param  {Object} delta Object with a width/height change.
     * @return {type}
     */
    resizeByDelta(win: any, delta: any): any;
    getMovingDirection(bounds: any, win: any): string;
    /**
     * Does the dirty work of actually moving windows.
     * @param  {moveRequest} bounds
     * @param  {function} callback
     */
    moveWindow(bounds: any, callback?: any): void;
    private checkMoveDockedCommponent;
    /**
     * Checks to see whether a window can be snapped to other windows/monitors.
     * @param  {moveRequest} bounds
     * @param  {function} callback
     */
    checkBuffers(moveRequest: any, cb: (modifiedRequest: any) => void): void;
    /**
     * Spins through windows and fixes opacity. For onMouseMove, we skip any windows that could be snapped to the movingWindow. onMouseUp, everything gets hit.
     * @param  {object} params
     * @param  {object} params.checkForSnappability
     */
    fixWindowOpacity(params: any): void;
    /**
     * Happens when config is loaded from the configClient.
     */
    setGlobalMinimums(serviceConfig: any): void;
    /** **************************************
     *			Calculators - general		*
     *************************************** */
    /**
     * Given an object, will set boundingboxes on it. If it's a dockableWindow, it'll let the window set itself up.
     * @param  {dockableWindow} win
     * @return {type}
     */
    setBoundingBoxes(win: any): any;
    /**
     * Returns the difference between the movingWindow's location and the requested movement.
     * @param  {moveRequest} moveRequest
     * @return {type}
     */
    getMoveDelta(moveRequest: any, oldBounds?: any): {
        x: number;
        y: number;
    };
    /**
     * Returns the inner bounds. We use this to give the windows some internal stickiness.
     * @param  {type} bounds
     * @return {object}
     */
    getInnerBoundingBox(bounds: any): {
        min: {
            x: any;
            y: any;
        };
        max: {
            x: number;
            y: number;
        };
    };
    /**
     * Gets the snapping buffer of a request.
     * @param  {type} request
     * @return {type}
     */
    getBuffer(request: any): {
        min: {
            x: number;
            y: number;
        };
        max: {
            x: any;
            y: any;
        };
    };
    /**
     * Given a request, a window, and a region, it'll tell you whether they intersect. We use this to figure out which corner/edge to snap to.
     * @param  {moveRequest} moveRequest
     * @param  {dockableWindow} stationaryWindow
     * @param  {string} stationaryRegion
     * @return {object}
     */
    getIntersections(moveRequest: any, stationaryWindow: any, stationaryRegion: any): string[];
    /** **************************************
     *				Iterators				*
     *************************************** */
    groupWindowIterator(group: DockableGroup, orderAnchor?: DockableWindow | null): Generator<DockableWindow, void, unknown>;
}
export default DockingCalculator;
//# sourceMappingURL=dockingCalculator.d.ts.map