interface ISize {
    w: number;
    h: number;
}

interface IRect extends ISize {
    x: number;
    y: number;
}

interface ISlotInfo {
    id?: string;
    type?: 'v' | 'h';
    rect?: IRect;
    weight?: number;
    children?: ISlotInfo[];
    keep?: boolean;
}
interface ISlot extends ISlotInfo {
    parent?: ISlot | null;
    children?: ISlot[];
    prev?: ISlot | null;
    next?: ISlot | null;
}

declare class SlotSnapshot {
    readonly slot: ISlot;
    readonly slots: ReadonlyMap<string, ISlot>;
    constructor(slot: ISlot);
    find(slot_id: 0): ISlot;
    find(slot_id: string | 0): ISlot | undefined;
    rect(slot_id?: 0): IRect;
    rect(slot_id: string): IRect | undefined;
    w(slot_id?: 0): number;
    w(slot_id: string): number | undefined;
    w(slot_id: string, or: number): number;
    weight(slot_id?: 0): number;
    weight(slot_id: string): number | undefined;
    pure(root?: ISlot): ISlotInfo;
}

interface IAdapter<Container = any> {
    container: Container;
    /**
     * Workspaces对象被创建时，该函数被调用
     *
     * be called when the Workspaces object is created.
     *
     * @param {Workspaces} ws
     */
    workspaces_create(ws: Workspaces): void;
    /**
     * Workspaces对象release时，该函数被调用
     *
     * be called when the Workspaces object is released.
     *
     * @param {Workspaces} ws
     */
    workspaces_release(ws: Workspaces): void;
    /**
     * 用于告知Workspaces对象，当前的工作区域大小
     * It is used to inform the Workspaces object of the current size of the working area.
     *
     * @param {Workspaces} ws
     * @returns {IRect}
     */
    workspaces_rect(ws: Workspaces): IRect;
    /**
     * Slot对象被创建时，该函数被调用
     *
     * This function is called when the Slot object is created.
     *
     * @param {Slot} slot
     */
    slot_create(slot: Slot): void;
    /**
     * Slot对象发生变化时，该函数被调用。
     * This function is called when the Slot object changes.
     *
     * 在这个函数中，你应该根据slot对象的rect属性，来调整的对应UI对象的位置与尺寸。
     * In this function, you should adjust the position and size of the corresponding UI object based on the rect property of the slot object.
     *
     * 比如在我们的项目splitting.dom.js中，我们会调整对应的dom元素的位置与尺寸。
     * For example, in project "splitting.dom.js", we will adjust the position and size of the corresponding DOM elements.
     *
     * 代码如下：
     * The code is as follows:
     *
     * ```js
     * slot_update(slot: Slot): void {
     *   const element: HTMLElement | undefined = this._slot_cell_map.get(slot);
     *   if (!element) return;
     *   element.style.left = '' + slot.rect.x + 'px'
     *   element.style.top = '' + slot.rect.y + 'px'
     *   element.style.width = '' + slot.rect.w + 'px'
     *   element.style.height = '' + slot.rect.h + 'px'
     * }
     * ```
     *
     * @param {Slot} slot
     */
    slot_update(slot: Slot): void;
    /**
     * Slot对象被销毁时，该函数被调用
     *
     * @param {Slot} slot
     */
    slot_release(slot: Slot): void;
    crossdot_create(cd: CrossDot): void;
    crossdot_drag_begin(cd: CrossDot, x: number, y: number): void;
    crossdot_drag_end(cd: CrossDot, x: number, y: number): void;
    crossdot_hover_begin(cd: CrossDot): void;
    crossdot_hover_end(cd: CrossDot): void;
    crossdot_update(cd: CrossDot): void;
    crossdot_release(cd: CrossDot): void;
    line_create(line: Line): void;
    line_drag_begin(line: Line, x: number, y: number): void;
    line_drag_move(line: Line, x: number, y: number): void;
    line_drag_end(line: Line, x: number, y: number): void;
    line_update(line: Line): void;
    line_release(line: Line): void;
}

type SlotFinding = string | 0 | (number | string | ((slot: Slot) => boolean))[] | ((slot: Slot) => boolean);
declare class Workspaces<Adapter extends IAdapter = IAdapter> {
    private _adapter;
    private _slot_min_size;
    private _new_slot_id;
    private _root;
    readonly prev_line_map: Map<string, Line>;
    readonly next_line_map: Map<string, Line>;
    private _slots;
    private _leaves;
    private _leaf_dirty;
    private _leaf_ids;
    get slots(): Map<string, Slot>;
    get leaves(): ReadonlyArray<Slot>;
    get slot_min_size(): ISize;
    get root(): Slot;
    get adapter(): Adapter;
    constructor(adapter: Adapter, info?: Partial<ISlot>);
    release(): void;
    on_resize: () => false | undefined;
    on_leaves_changed?: (self: Workspaces) => void;
    on_changed?: (self: Workspaces) => void;
    new_slot_id(): string;
    set_root(root: Slot): void;
    del_slot(s: Slot): void;
    del(slot_id: string): Slot | undefined;
    find(finding: SlotFinding): Slot | undefined;
    edits(slot_ids: SlotFinding[], mode: 0, fn: (slots: (Slot | undefined)[]) => void): void;
    edits(slot_ids: SlotFinding[], mode: 1, fn: (slots: Slot[]) => void): void;
    edits(slot_ids: SlotFinding[], mode: 2, fn: (slots: Slot[]) => void): void;
    edit(slot_id: SlotFinding, fn: (slot: Slot) => void): void;
    protected new_slot(...args: ConstructorParameters<typeof Slot>): Slot;
    add(anchor_slot_id: SlotFinding, pos: 'up' | 'down' | 'left' | 'right' | number, info?: Partial<ISlot>): [Slot | null, Slot | null];
    move(target_slot_id: SlotFinding, anchor_slot_id: SlotFinding, pos: 'up' | 'down' | 'left' | 'right' | number): Slot | undefined;
    update_rects(slot: Slot, obj?: {
        ok: boolean;
    }): boolean;
    update_lines(slot: Slot): void;
    update_slot(slot: Slot): void;
    confirm(): void;
    update(): false | undefined;
    slots_dirty(): void;
    debug_output(...args: any[]): void;
    error_output(err: Error): void;
    print_slot(n?: Partial<Slot>, level?: string): void;
    array_tree(n?: Partial<Slot>): ArrayTreeNode<string>;
}
type ArrayTreeNode<I> = I | [I, ArrayTreeNode<I>[]];

declare class Slot implements ISlot {
    private _children;
    readonly workspaces: Workspaces;
    readonly id: string;
    private _parent;
    private _prev;
    private _next;
    private _type;
    private _min_size;
    private _crosscut;
    private _slitting;
    private _keep;
    private _weight;
    private _rect;
    get rect(): Readonly<IRect>;
    set rect(v: Readonly<IRect>);
    edit_rect(fn: (rect: IRect) => IRect): void;
    get weight(): number;
    set weight(v: number);
    get type(): 'v' | 'h';
    set type(v: 'v' | 'h');
    get min_size(): Readonly<ISize>;
    get children(): Slot[];
    get parent(): Slot | null;
    get grandparent(): Slot | null;
    get prev(): Slot | null;
    get next(): Slot | null;
    get keep(): boolean;
    set keep(v: boolean);
    get root(): Slot;
    get crosscut(): number;
    get slitting(): number;
    set crosscut(v: number);
    set slitting(v: number);
    constructor(workspaces: Workspaces, info?: Partial<ISlot>);
    confirm(): void;
    clone(): Slot;
    snapshot(no_children?: boolean): SlotSnapshot;
    update_dimension(): void;
    update_weight(): void;
    update_rect(rect: IRect): void;
    protected _link_up(): void;
    protected _snapshot(no_children?: boolean): ISlot;
    _handle_new_children(slots: Slot[]): void;
    insert(index: number, ...slots: Slot[]): void;
    unshift(...slots: Slot[]): void;
    shift(): Slot | undefined;
    remove(slot: Slot): boolean;
    replace(index: number, ...slots: Slot[]): Slot | undefined;
    replace(slot: Slot, ...slots: Slot[]): Slot | undefined;
    push(...slots: Slot[]): void;
    removed(trim?: boolean): void;
    release(trim?: boolean): void;
    get_my_depth(): number;
    get_max_depth(depth?: number): number;
    find_slot(fn: (slot: Slot) => boolean): Slot | undefined;
}

declare class Line {
    slot: Slot;
    prev: Slot;
    next: Slot;
    private snapshots;
    private ok_weights;
    readonly workspaces: Workspaces;
    private prev_cross_dot;
    private next_cross_dot;
    get actived(): boolean;
    private _actived;
    private _down;
    private _move;
    save_weights(slot: Slot): void;
    restore_weights(slot: Slot): void;
    drag_begin(x: number, y: number): void;
    drag_move(x: number, y: number): void;
    drag_end(): void;
    constructor(workspaces: Workspaces, slot: Slot, prev: Slot, next: Slot);
    private _update_dot;
    update_slots(slot: Slot, prev: Slot, next: Slot): void;
    update_dots(): void;
    release(): void;
}

declare class CrossDot {
    readonly lines: Line[];
    readonly workspaces: Workspaces;
    readonly type: 'prev' | 'next';
    constructor(workspaces: Workspaces, type: 'prev' | 'next', lines: Line[]);
    release(): void;
    update(): void;
}

export { CrossDot, Line, Slot, SlotSnapshot, Workspaces };
export type { IAdapter, IRect, ISize, ISlot, ISlotInfo, SlotFinding };