import { VNode } from 'snabbdom/vnode';
import { Renderable, RemoveChildArgs, AddChildArgs, ConfiguredRenderable, BaseModificationArgs, RenderableDestroyContext } from '../dom';
import { RenderableArg, XYDirection, ContextType } from '../common';
import { Row, Column } from '../XYContainer';
import { StackHeader, StackHeaderConfigArgs } from './StackHeader';
import { StackItemContainer, StackItemContainerConfig } from './StackItemContainer';
import { StackTab } from './StackTab';
import { StackRegion } from './common';
import { RenderableConfigArgs, RenderableConfig } from '../dom';
import { StackControl } from './controls';
export interface StackConfig extends RenderableConfig {
    children: StackItemContainerConfig[];
    startIndex: number;
    direction: XYDirection;
    reverse: boolean;
    header: StackHeaderConfigArgs | null;
    controls: RenderableArg<StackControl>[];
}
export interface StackConfigArgs extends RenderableConfigArgs {
    children: StackItemContainerConfig[];
    startIndex?: number;
    direction?: XYDirection;
    reverse?: boolean;
    header?: StackHeaderConfigArgs;
    controls?: RenderableArg<StackControl>[];
}
/**
 * A Renderable that renders the Renderable items in a tabbable format.
 * @export
 * @class Stack
 * @extends {Renderable}
 */
export declare class Stack extends Renderable {
    private _header;
    private _activeIndex;
    protected _contentItems: StackItemContainer[];
    protected _config: StackConfig;
    protected _container: Renderable;
    protected _StackHeader: typeof StackHeader;
    protected _StackItemContainer: typeof StackItemContainer;
    protected _Row: typeof Row;
    protected _Column: typeof Column;
    /**
     * The direction of the stack.
     * @readonly
     * @type {XYDirection}
     */
    readonly direction: XYDirection;
    /**
     * Whether the stack is horizontal.
     * @readonly
     * @type {boolean}
     */
    readonly isHorizontal: boolean;
    /**
     * Whether the stack is reversed
     * @readonly
     * @type {boolean}
     */
    readonly isReversed: boolean;
    readonly width: number;
    readonly height: number;
    /**
     * Whether this stack is considered closable.
     * @readonly
     * @type {boolean}
     */
    readonly isCloseable: boolean;
    /**
     * The active content item index.
     * @readonly
     * @type {number}
     */
    readonly activeIndex: number;
    /**
     * The header associated with this stack.
     * @readonly
     * @type {StackHeader}
     */
    readonly header: StackHeader;
    /**
     * Gets the content items.
     * @readonly
     * @type {StackItemContainer[]}
     */
    readonly items: StackItemContainer[];
    /**
     * @listens {TabCloseEvent}
     * @listens {TabSelectionEvent}
     * @listens {TabDragEvent}
     */
    initialize(): void;
    render(): VNode;
    /**
     * Creates a child {@link StackItemContainer}.
     * @param {StackItemContainerConfig} config
     * @returns {StackItemContainer}
     */
    createChildItem(config: StackItemContainerConfig): StackItemContainer;
    /**
     * Adds a header control to this stack.
     * @param {RenderableArg<StackControl>} control
     */
    addControl(control: RenderableArg<StackControl>): void;
    /**
     * Adds a child renderable. If the renderable being added is not a StackItemContainer
     * then one is created and the item is wrapped in it.
     * @param {Renderable} item
     * @param {AddChildArgs} [options={}]
     */
    addChild(item: Renderable, options?: AddChildArgs): void;
    /**
     * Removes a child item along with the tab associated with.
     * @param {StackItemContainer} item
     * @param {RemoveChildArgs} [options={}]
     * @returns {void}
     */
    removeChild(item: StackItemContainer, options?: RemoveChildArgs): void;
    /**
     * Sets the active item at a specific index.
     * @param {number} [index]
     * @param {BaseModificationArgs} [args={}]
     */
    setActiveIndex(index?: number, args?: BaseModificationArgs): void;
    /**
     * Removes an item a specified index.
     * @param {number} index
     * @param {RemoveChildArgs} [options={}]
     */
    removeAtIndex(index: number, options?: RemoveChildArgs): void;
    /**
     * Closes the stack if all items are closeable.
     * @emits {BeforeDestroyEvent} Event that can prevent this action.
     * @returns {void}
     */
    close(context?: ContextType): void;
    destroy(context: RenderableDestroyContext): void;
    getChildren(): Renderable[];
    /**
     * Gets the index of a tab.
     * @param {StackTab} tab
     * @returns {number}
     */
    getIndexOfTab(tab: StackTab): number;
    /**
     * Determines whether an item is the action item container.
     * @param {StackItemContainer} container
     * @returns {boolean}
     */
    isActiveContainer(container: StackItemContainer): boolean;
    /**
     * Determines whether a tab is the active tab.
     * @param {StackTab} tab
     * @returns {boolean}
     */
    isActiveTab(tab: StackTab): boolean;
    /**
     * Gets a tab at a specified index.
     * @param {number} index
     * @returns {(StackTab|null)}
     */
    getTabAtIndex(index: number): StackTab | null;
    /**
     * Sets the given container as the active item.
     * @param {StackItemContainer} container
     */
    setActiveContainer(container: StackItemContainer): void;
    /**
     * Sets the active item from the given tab.
     * @param {StackTab} tab
     */
    setActiveTab(tab: StackTab): void;
    getMinimizedSize(): number;
    /**
     * Gets the leaf nodes of the active item container.
     * @override
     * @returns {Renderable}
     */
    getLeafNodes(): Renderable[];
    /**
     * Handles a renderable being dropped on the stack within a certain region.
     * @param {StackRegion} region The region the item was dropped in.
     * @param {Renderable} item The item being dropped.
     */
    handleItemDrop(region: StackRegion, item: Renderable): void;
    isRenderable(): boolean;
    private _createContainerFromRegion;
    private _getContainerDropType;
    private _onTabClose;
    private _onTabSelect;
    private _onTabDrag;
    private _setActiveIndex;
    static configure(config: StackConfigArgs): ConfiguredRenderable<Stack>;
}