import { Event } from '../../../events';
import { CompositeDisposable } from '../../../lifecycle';
import { DockviewComponent } from '../../dockviewComponent';
import { DockviewGroupPanel } from '../../dockviewGroupPanel';
import { DockviewWillShowOverlayLocationEvent } from '../../events';
import { IDockviewPanel } from '../../dockviewPanel';
import { DockviewHeaderDirection } from '../../options';
import { Tab } from '../tab/tab';
import { TabDragEvent, TabDropIndexEvent } from './tabsContainer';
export declare class Tabs extends CompositeDisposable {
    private readonly group;
    private readonly accessor;
    private readonly _element;
    private readonly _tabsList;
    private readonly _observerDisposable;
    private readonly _scrollbar;
    private _tabs;
    private readonly _tabMap;
    private selectedIndex;
    private _showTabsOverflowControl;
    private _direction;
    private _animState;
    private readonly _pendingMarginCleanups;
    private _pendingCollapse;
    private _flipTransitionCleanup;
    private _voidContainer;
    private _voidContainerListeners;
    private _extendedDropZone;
    private _pointerInsideTabsList;
    private readonly _tabGroupManager;
    private readonly _onTabDragStart;
    readonly onTabDragStart: Event<TabDragEvent>;
    private readonly _onDrop;
    readonly onDrop: Event<TabDropIndexEvent>;
    private readonly _onWillShowOverlay;
    readonly onWillShowOverlay: Event<DockviewWillShowOverlayLocationEvent>;
    private readonly _onOverflowTabsChange;
    readonly onOverflowTabsChange: Event<{
        tabs: string[];
        tabGroups: string[];
        reset: boolean;
    }>;
    get showTabsOverflowControl(): boolean;
    set showTabsOverflowControl(value: boolean);
    get element(): HTMLElement;
    set voidContainer(el: HTMLElement | null);
    /**
     * Handle a drop that occurred on the void container (empty header
     * space to the right of the tabs). Returns `true` if the drop was
     * consumed by an active group drag, `false` otherwise.
     */
    handleVoidDrop(): boolean;
    get panels(): string[];
    get size(): number;
    get tabs(): Tab[];
    get direction(): DockviewHeaderDirection;
    set direction(value: DockviewHeaderDirection);
    constructor(group: DockviewGroupPanel, accessor: DockviewComponent, options: {
        showTabsOverflowControl: boolean;
    });
    indexOf(id: string): number;
    isActive(tab: Tab): boolean;
    setActivePanel(panel: IDockviewPanel): void;
    openPanel(panel: IDockviewPanel, index?: number): void;
    delete(id: string): void;
    private addTab;
    private toggleDropdown;
    updateDragAndDropState(): void;
    /**
     * Synchronize chip elements and CSS classes for all tab groups
     * in the parent group model. Call after any tab group mutation.
     */
    updateTabGroups(): void;
    refreshTabGroupAccent(): void;
    /**
     * Tabs-list-specific side effects of a chip drag start. The chip's
     * drag sources (constructed by `TabGroupManager`) own the transfer
     * payload, iframe shielding, dataTransfer setup, and the HTML5 drag
     * image. This method just sets up the smooth-reorder anim state and
     * collapses the source-group tabs in the tabs list.
     */
    private _handleChipDragStart;
    /**
     * A drop on a tab group chip means "insert before this group". Resolve to
     * the index of the group's first tab, adjusting for same-group removal
     * (when the source tab is currently to the left of the target slot, its
     * removal shifts the insertion index down by one). Always clears
     * `targetTabGroupId` so the dropped tab lands outside the group.
     */
    private _handleChipDrop;
    /**
     * Sets the broader container that is part of the same logical drop surface
     * as this tab list (e.g. the full header element).  When a dragleave from
     * the tabs list lands inside this container, `_animState` is preserved so
     * that external dragover listeners can continue the animation.
     */
    setExtendedDropZone(el: HTMLElement): void;
    /**
     * Allows external elements (e.g. void container, left actions) to push an
     * insertion index into the animation while the cursor is outside the tabs
     * list itself.  Pass `null` to clear the indicator.
     */
    setExternalInsertionIndex(index: number | null): void;
    /**
     * Called when the drag cursor leaves the entire header area (not just the
     * tabs list).  Clears animation state for cross-group drags, which never
     * receive a `dragend` event on this tab list.
     */
    clearExternalAnimState(): void;
    private snapshotTabPositions;
    private getAverageTabWidth;
    /**
     * Pointer-event entry point. The HTML5 path enters via the per-element
     * `dragover` listener; this one hit-tests the global pointer-drag
     * position against the tabs list and routes through the same shared
     * `_processDragOver` / `_processDragLeave` helpers.
     */
    private _handlePointerDragMove;
    /**
     * Shared body of the dragover entry point. Refreshes stale anim state
     * for a changed drag identity, initializes anim state for incoming
     * cross-group drags, and dispatches to the gap-following math in
     * `handleDragOver`. Returns true when this tabs list has taken
     * ownership of the drag — HTML5 callers use this to gate
     * `event.preventDefault()`.
     */
    private _processDragOver;
    /**
     * Shared body of the dragleave entry point. Preserves anim state when
     * the drag moves between tabs-list children, into the extended drop
     * zone, or into the void container; tears it down otherwise.
     */
    private _processDragLeave;
    private handleDragOver;
    /**
     * Batch-remove a CSS class from multiple elements instantly,
     * forcing only a single reflow for the entire batch.
     */
    private _removeClassInstantlyBatch;
    /**
     * Remove `dv-tab--dragging` from the source tab instantly so it
     * regains its real width before FLIP snapshots.
     */
    private _uncollapsSourceTab;
    private applyDragOverTransforms;
    private resetTabTransforms;
    /**
     * Commit a group-drag drop: clear drag classes, move the group
     * in the model, and run a FLIP animation.
     */
    private _commitGroupMove;
    private _clearGroupDragClasses;
    private resetDragAnimation;
    private runFlipAnimation;
}