import DockableBox from "./dockableBox";
import DockingCalculator from "./dockingCalculator";
import FinsembleEvent from "../../../common/events/FinsembleEvent";
import { DockableMonitor } from "./dockableMonitor";
import { MonitorInfoDetail } from "../../../FEA";
import { StandardCallback, StandardPromise } from "../../../types";
import { FSBLWindow } from "../types";
import { DockingConfigOptions, DefaultDockingOptions, DockedDimensions, DockingBounds, Vertex, MonitorDockablePositions, BoxCoordinates, MoveRequest, DockingSimulatedEvent, SnappedObject } from "./types";
export declare class DockableWindow extends DockableBox {
    win: FSBLWindow;
    canGroup: boolean;
    name: string;
    guid: string;
    hasDashbarData: boolean;
    opacity: number;
    groupNames: string[];
    snappedWindows: SnappedObject[];
    calculator: DockingCalculator;
    resizeThrottlePeriod: number;
    changeTaskbarVisibilityQueue: Function;
    lastBoundsAdjustment: number;
    animate: Function;
    shouldOffsetByMouse: boolean;
    allowTiling: boolean;
    allowTabbing: boolean;
    canMinimize: boolean;
    shouldShowTaskbarIcon: boolean;
    isDockableComponent: boolean;
    monitorDockablePositions: MonitorDockablePositions;
    dockingOptions: DockingConfigOptions;
    dockedPosition: number | undefined;
    ignoreSnappingRequests: boolean;
    dockedDimensions: DockedDimensions | null;
    undockedPosition: DockedDimensions;
    primaryMonitor?: MonitorInfoDetail;
    isHidden: boolean;
    dockedParams: DockingConfigOptions;
    dockedHeight: number;
    snappedEdge: string;
    dockedMonitor?: DockableMonitor;
    snappedMonitor?: DockableMonitor;
    monitor: DockableMonitor;
    onboundschanged: number;
    previouslySnappedEdge?: boolean;
    dockedBounds?: DockingBounds;
    justDocked?: boolean;
    vertices: Record<string, Vertex>;
    groups: string[];
    closeEventListener?: Function;
    finished: boolean;
    limits: any;
    edges: any;
    onGroupEdge: any;
    justUndocked: boolean;
    /**
     * Creates DockableWindow instances.
     */
    static factory(win: FSBLWindow, bounds: BoxCoordinates, calculator: DockingCalculator): DockableWindow;
    /**
     * Do not construct DockableWindow directly. Use the factory
     *
     * @param {*} win Window object; WebWindow, ExternalWindow, etc.
     * @param {bounds} bounds initial bounds for the window.
     * @param {object} dependencies Dependency object that provides the calculator, System, and Logger.
     * @param {DockingCalculator} dependencies.calculator
     * @param {System} dependencies.System
     * @param {Logger} dependencies.Logger
     */
    private constructor();
    private setMonitorDockablePosition;
    private computeDockingDefaults;
    private setminMaxWidths;
    private initialize;
    private dockToMonitor;
    private recallBounds;
    private getLocValue;
    private recallDockedPosition;
    /**
     * Returns turn if the current monitor dimensions are different from the previous monitor dimensions
     * @param {array} previousMonitorData the previous monitor info (an array of monitors)
     */
    monitorChanged(previousMonitorData: MonitorInfoDetail[]): Promise<boolean>;
    /**
     * Returns turn if the toolber handle (i.e. what the user can grab to move toolbar) is visible on one of the current monitors (based on the toolbars current bounds
     * @param {array} currentBounds the toolbars current bounds
     */
    isToolbarVisible(currentBounds: DockingBounds): Promise<boolean>;
    /**
     * Returns a string representation of the docked location
     */
    getDockedStringFromLocation(): string | null;
    /**
     * Function to respond to finWindow bounds-changed events. Currently we only respond to this event in some cases.
     * Aero_key: Sets bounds after an aero snap action is initiated (windows key + arrow key). Only triggers if Aero is enabled.
     * System_restored: Triggered when a window is restored from minimized outside of Finsemble. This code block should only be hit if the
            monitor configuration has changed after a window is minimized and the window's old restore position would be partially off-monitor.
            The OS does not change the bounds of minimized windows, so they only action we can take	is to force it on monitor.
     * @param {object} e The event
     */
    onSystemMovedWindow(e: FinsembleEvent): void;
    /**
     * Builds default docking options for dockable windows
     * @param {object} options Taken from the incoming config
     * @return {object} The docking defaults
     */
    buildDefaultDockingOptions(options: DockingConfigOptions): DefaultDockingOptions;
    /**
     * Function to handle chain of events when a dockable component type is docked
     *
     * @param {object} monitor Information about the monitor the component was docked to
     * @param {string} location A string containing the location to dock to: "TOP", "LEFT", "BOTTOM", and "RIGHT" are the acceptable values
     */
    dock(monitor: MonitorInfoDetail, oldBounds: DockingBounds, location: number): void;
    /**
     * Function to handle chain of events when a dockable component type is undocked
     */
    undock(isClosing?: boolean): void;
    saveDockableData(): void;
    /**
     * @function {function name}
     * @return {type} {description}
     */
    onBoundsChanged(): void;
    hiddenUnclaimSpace(): void;
    unhiddenClaimSpace(): void;
    /**
     * @function {function name}
     * @param  {type} request  {description}
     * @param  {type} callback {description}
     * @return {type} {description}
     */
    onBoundsChanging(event: DockingSimulatedEvent | FinsembleEvent, cb?: () => void): Promise<void>;
    setResizeThrottlePeriod(throttlePeriod: number): void;
    restored(event: FinsembleEvent): Promise<void>;
    maximized(): void;
    /**
     * This removes event listeners.
     * I can't be entirely certain, but from my testing, it _appears_ that Electron isn't actually deleting these objects.
     * If you close the window, then load the window with the same name, old listeners are still registered with your new window.
     * So if you reload a workspace, and then try to move a window, you get weird scenarios where onBoundsChanging is called twice with different values (presumably for old eventlisteners).
     * Removing the eventListeners on close seems to handle this.
     */
    removeEventListeners(): void;
    /** ******************************************
     *											*
     *			Window Moving Methods			*
     *											*
     ******************************************* */
    /**
     * Hides taskbar icon for windows. This prevents them from being clobbered by aeroshake.
     */
    hideTaskbarIcon(): void;
    /**
     * This shows the taskbar icon for a given window.
     */
    showTaskbarIcon(showIcon?: boolean): void;
    /**
     * @function {function name}
     * @return {type} {description}
     */
    disableFrame(): void;
    setOpacity(params?: {
        opacity: number;
        persist?: boolean;
    }): void;
    /**
     * Sets bounds for internal calculations.
     */
    setInternalBounds(bounds: DockingBounds): void;
    /**
     * @function {function name}
     * @param  {type} bounds    {description}
     * @param  {type} successCB {description}
     * @param  {type} errCB     {description}
     * @return {type} {description}
     */
    setBounds(bounds: DockingBounds, successCB?: StandardCallback): StandardPromise<void>;
    /**
     * @function {function name}
     * @param  {type} left {description}
     * @param  {type} top  {description}
     * @return {type} {description}
     */
    moveTo(left: number, top: number): void;
    /**
     * @function {function name}
     * @return {type} {description}
     */
    getGroupNames(): string[];
    /**
     * @function {function name}
     * @param  {type} request  {description}
     * @param  {type} callback {description}
     * @return {type} {description}
     */
    requestBoundsChange(request: MoveRequest, callback: () => void): void;
    /** ******************************************
     *											*
     *			Helper Functions				*
     *											*
     ******************************************* */
    /**
     * @function {function name}
     * @return {type} {description}
     */
    calculateInnerBoundingBox(): {
        min: {
            x: number;
            y: number;
        };
        max: {
            x: number;
            y: number;
        };
    };
    getInnerBoundingBox(): import("./types").BoundingBox;
    /**
     * @function {function name}
     * @param  {type} bufferSize {description}
     * @return {type} {description}
     */
    setBufferSize(bufferSize: number): void;
    /**
     * @function {function name}
     * @return {type} {description}
     */
    setBoundingBoxes(): void;
    getSnappingRegions(): import("./types").SnappingRegions;
    updateState(): void;
    /**
     * @function setHidden
     * @param  {function=} callback when done
     *
     * Sets the internal state to hidden.  Only needed if window is hidden outside of this class.
     */
    setHidden(): void;
    /**
     * @function setHidden
     * @param  {function=} callback when done
     *
     * Sets the internal state to shown (i.e. not hidden). Only needed if window is hidden outside of this class.
     */
    setShown(): void;
    hide(cb?: StandardCallback): void;
    show(cb?: StandardCallback): void;
    maximize(cb?: StandardCallback): void;
    minimize(cb?: StandardCallback): void;
    restore(cb?: StandardCallback): void;
    alwaysOnTop(isAlwaysOnTop: boolean): void;
    /**
     * Returns the present alwaysOnTop status of the window.
     *
     * NOTE: This only reflects Finsemble's internal representation
     * of the alwaysOnTop status, not the container/OS. When changing the status,
     * Finsemble's status changes before the underlying container, causing them
     * to briefly become out of sync.
     */
    isAlwaysOnTop(): boolean;
    bringToFront(): void;
    notifyWindowTitleBarOfGroupMembership(): void;
    notifyWindowTitleBarOfGroupEjection(): void;
    addSnappedWindow(snapObj: SnappedObject): void;
    removeSnappedWindow(name: string): void;
    animatePositionAndHeight(params: DockingBounds, cb: StandardCallback): void;
    isGrouped(): boolean;
    /**
     * Adds eventListeners so that when the finWIndow moves, we can do things with that data.
     */
    addListeners(): void;
}
export default DockableWindow;
//# sourceMappingURL=dockableWindow.d.ts.map