import { WindowGroup } from "../../../common/window/windowGroup";
import DockableBox from "./dockableBox";
import { BoundingBox, DockingConfig, SystemMove, JSONGroupRepresentation, Vertex, BoxCoordinates, SnapObject, Corner, CornersAndEdges, DockingBounds, MoveToParams, XYCoordinates, ScaledBounds, TetrisBounds } from "./types";
import DockingCalculator from "./dockingCalculator";
import DockableWindow from "./dockableWindow";
export declare class DockableGroup extends WindowGroup {
    setBuffer: (bufferSize?: number | undefined) => void;
    getEdges: (format: string, includeCorners?: number | boolean | undefined) => import("./types").Edges | BoundingBox[];
    getCornerObject: (req: any) => Record<string, Vertex>;
    sharesAnEdgeWith: (win: BoxCoordinates) => boolean;
    getSharedEdges: (win2: BoxCoordinates, tolerance?: number) => import("./types").SharedEdges;
    name: string;
    willReform: boolean;
    isMovable: boolean;
    ungroupedAlwaysOnTopState: object;
    windowBoundingBox: BoundingBox;
    fillAttempts: number;
    dockableBox: DockableBox;
    deferredWindowMoves: SystemMove[];
    windows: DockableWindow[];
    isAlwaysOnTop: boolean;
    left: number;
    right: number;
    bottom: number;
    top: number;
    width: number;
    height: number;
    MINIMUM_WINDOW_WIDTH: number;
    MINIMUM_WINDOW_HEIGHT: number;
    vertices: Record<string, Vertex>;
    /**
     *
     * @param {*} config Config for the group. See WindowGroup for more.
     * @param {*} dependencies Dependency object that provides a Logger.
     */
    constructor(config: DockingConfig);
    pointIsOnBoundingBox(point: XYCoordinates, includeCorners?: boolean): boolean;
    /**
     * Fired when the alwaysOnTop of a window in the group changes.
     * Sets all windows in the group to the new value.
     */
    handleAlwaysOnTopChange({ data: { alwaysOnTop } }: {
        data: {
            alwaysOnTop: any;
        };
    }): void;
    /**
     * Returns the JSON representation of the group (stored on the workspace).
     */
    getJSON(): JSONGroupRepresentation;
    /**
     * Responds to system events when the OS has moved a group. Every time a window in this group triggers this function a shared array will
     * be updated with that window and it's bounds. After each update, request the group move.
     * If this function is triggered again within a certain time, the group move will continue to be delayed until enough time passes without
     * any windows events. Ideally the group will only move when all windows in the group with changes have responded to events.
     * @param {*} windowObject - Contains the window name and it's updated bounds
     * @param {*} calculator - an instance of docking calculator
     */
    deferSystemMove(windowObject: SystemMove, calculator: DockingCalculator): void;
    /**
     * Requests the group move. Uses an array of windows in the group and their bounds to choose which window's bounds to use for the group move.
     * Intended to move a group after the monitor configuration has changed as the OS may not keep the group intact when it is moved.
     *
     * @param {*} calculator
     * @param {*} deferredWindowMoves array of windowobjects to be used for the move.
     */
    performDeferredSystemMove(calculator: DockingCalculator, deferredWindowMoves: SystemMove[]): void;
    addWindow(win: DockableWindow): void;
    updateBounds(): void;
    saveIndividualWindowStates(): void;
    startMove(): void;
    stopMove(): void;
    getWindowsOnEdges(): {};
    isARectangle(): boolean;
    /**
     * When you move a group of windows left to right, the anchor algorithm finds the left-most window, and then sorts all of the windows on how close they are to that window. This function just finds the appropriate anchor for that move.
     * @param {*} movingDirection
     */
    getMoveAnchor(movingDirection: string): DockableWindow;
    /**
     * Used for resize. Grabs the windows on the opposite side of the resize handle.
     * @function {function name}
     * @param  {type} handle {description}
     * @return {type} {description}
     */
    getAnchors(handle: string): string[];
    /**
     * @function {function name}
     * @return {type} {description}
     */
    calculateOuterBounds(): BoundingBox | null;
    /**
     * @function {function name}
     * @param  {type} name {description}
     * @return {type} {description}
     */
    removeWindow(name: string, updateAOT?: boolean): void;
    /**
     * @function {function name}
     * @param  {type} bounds {description}
     * @return {type} {description}
     */
    getDelta(bounds: DockingBounds): DockingBounds;
    /**
     * @function {function name}
     * @param  {type} bounds {description}
     * @return {type} {description}
     */
    setBounds(bounds: DockingBounds): void;
    getBounds(): TetrisBounds;
    /**
     *
     * @param {bounds} newBounds Bounds to scale the group to
     * @param {string} anchor
     * @param {DockingCalculator} calculator
     * @param {function} cb
     */
    scale(newBounds: DockingBounds, anchor: string, calculator: DockingCalculator): void;
    /**
     * Sets the minimum height and width for windows. This is used when scaling windows. It prevents us from creating very tiny windows when scaling an entire group.
     * @param {object} cfg
     * @param {number} cfg.MINIMUM_HEIGHT Minimum height a window can scale to.
     * @param {number} cfg.MINIMUM_WIDTH Minimum width a window can scale to.
     */
    setMinimums(cfg: DockingConfig): void;
    /**
     * Returns an array of windows that have an edge on a given line segment.
     * @param {object} segment
     * @param {object} segment.min minimum point for the line segment.
     * @param {number} segment.min.x X coordinate for the minimum point for the line segment.
     * @param {number} segment.min.y y coordinate for the minimum point for the line segment.
     * @param {object} segment.min maximum point for the line segment.
     * @param {number} segment.max.x X coordinate for the maximum point for the line segment.
     * @param {number} segment.max.y y coordinate for the maximum point for the line segment.
     * @returns {array} windowsOnSegment Array of dockable windows that have an edge on the line segment.
     */
    getWindowBoxesOnSegment(segment: BoundingBox): SnapObject[];
    /**
     * Not sure why this function doesn't use the one above. Similar functionality, 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): SnapObject[];
    private scaleRemainingWindows;
    /**
     * Given a hole, this function recursively fills the hole, expanding 1 window at a time - until the hole is filled.
     * @param {object} hole
     * @param {*} cb
     */
    fillHole(hole: BoxCoordinates): Promise<void>;
    moveTo(bounds: MoveToParams, cb?: Function): void;
    /**
     * In certain configurations, whether a group is a rectangle is _NOT_ the deciding factor in scaling it. Instead, that decision is made based on whether the user is dragging a corner or an edge. If it's a corner, it must not be on another window's edge. If those conditions are met, we scale the group. This function returns the list of x,y points that will trigger this behavior.
     */
    getCornersThatCauseScaling(): Corner[];
    /**
     * @typedef cornerLabel
     * @param {"topLeft"|"topRight"|"bottomLeft"|"bottomRight"} Label for the corner.
     */
    /**
     * @typedef cornerObject
     * @param {string?} window Name of the window the corner belongs to
     * @param {number} x X coordinate of the corner
     * @param {number} y Y coordinate of the corner
     * @param {cornerLabel} label for the corner.
     */
    /**
     * @typedef edgeObject
     * @param {string?} window Name of the window the edge belongs to
     * @param {object} min Minimum point for line segment
     * @param {number} min.x X coordinate of the minimum point for the edge's line segment.
     * @param {number} min.y Y coordinate of the minimum point for the edge's line segment.
     * @param {object} max maximum point for line segment
     * @param {number} max.x X coordinate of the maximum point for the edge's line segment
     * @param {number} max.y Y coordinate of the maximum point for the edge's line segment
     */
    /**
     * @typedef {object} cornersAndEdges
     * @param {Array<cornerObject>} corners
     * @param {Array<edgeObject>} edges
     */
    /**
     * Helper function that will return all corners and all edges for each window in the group.
     * @returns {cornersAndEdges} cornersAndEdges Corners and edges.

     */
    getCornersAndEdgesOfAllWindows(): CornersAndEdges;
    /**
     * Returns the scale of bounds 1 relative to bounds 2.
     * If bounds1 is 1, and bounds2 is 2, the scale will come out as 2.
     * If bounds1 is 10 and bounds2 is 5, the scale will come out as 0.5. This is done for both x and y
     * @param {bounds} bounds1
     * @param {bounds} bounds2
     */
    static getScaleDescriptor(bounds1: DockingBounds, bounds2: DockingBounds): XYCoordinates;
    /**
     * Essentially moves the window's top-left to the x/y coordinates passed in.
     * @param {object} params
     * @param {num} params.x x coordinate of a cartesian coordinate pair.
     * @param {num} params.y y coordinate of a cartesian coordinate pair.
     * @param {bounds} params.bounds bounds object that is being offset
     */
    static getCoordinatesByOffset(params: {
        x: number;
        y: number;
        bounds: DockingBounds;
    }): DockingBounds;
    /**
     * Given bounds and a scaleDescriptor, returns a scaled bounds object.
     * @param {*} params
     * @param {object} params.bounds Bounds.
     * @param {object} params.scaleDescriptor Tells us how much to scale in the X and Y directions.
     * @param {num} params.scaleDescriptor.x 0-Infinity; how much to scale the window in the x direction
     * @param {num} params.scaleDescriptor.y 0-Infinity; how much to scale the window in the y direction
     * @returns {object} bounds
     */
    static scaleWindow(params: {
        bounds: DockingBounds;
        scaleDescriptor: XYCoordinates;
    }): ScaledBounds;
    /**
     * Called after performing scale operations on the group. Depending on where the user scaled the group from, we re-anchor the group so that the move makes sense. Internally, resizes are calculated as if the group was at 0,0. After we do those calculations, we need to re-anchor the group so that the move makes intuitive sense.
     * @param {object} params
     * @param {array} params.windowList Array of bounds objects. Or windows. Haven't decided.ANGLE_instanced_arrays
     * @param {object} params.offset object describing by how much the top and left of a window's bounds should be offset.
     * @param {num} params.offset.left how much to offset the left edge of each window in the group.
     * @param {num} params.offset.top how much to offset the left edge of each window in the group.
     */
    static offsetGroup(params: {
        windowList: DockingBounds[];
        offset: DockingBounds;
    }): DockingBounds[];
    /**
     * The workhorse of scaling operations. Given a list of windows, how we want to scale them, where to put them after scaling, and a minimum height and width, it will do everything.
     * 1. Moves the group to 0,0.
     * 2. Calculates the size of each window in the array.
     * 3. Actually scales each window.
     * 4. Makes sure no windows got too narrow or too short (check minimum height/width).
     * 5. Fixes any windows that were too small/too narrow.
     * 6. Re-anchors the group so that the move "feels" right. See DockableGroup.'offsetGroup' for a better explanation of what "feels right" means.
     * @param {params} params
     * @param {Array<bounds>} params.windowList
     * @param {scaleDescriptor} params.scaleDescriptor how much to scale in the x and y dimensions.
     * @param {num} param.scaleDescriptor.x How much to scale in the x direction
     * @param {num} param.scaleDescriptor.y How much to scale in the y direction
     * @param {object} param.anchor top/left coordinates of the 'anchor' for the list of windows. After scaling the windows, we need to make sure every window is reset to this anchor. If one resizes from the bottom right of a group, the top left of the group shouldn't change. If you resize from the top left, the bottom right shouldn't move after scaling.
     */
    static getScaledWindowList(params: any): any;
}
export default DockableGroup;
//# sourceMappingURL=dockableGroup.d.ts.map