import { BubblingEvent, EventEmitter } from '../utils';
import type { ItemConfig } from '../config';
import type LayoutManager from '../LayoutManager';
import type Tab from '../controls/Tab';
import type Stack from './Stack';
import type Component from './Component';
import type Root from './Root';
export declare function isStack(item: AbstractContentItem): item is Stack;
export declare function isComponent(item: AbstractContentItem): item is Component;
export declare function isRoot(item: AbstractContentItem): item is Root;
export type ItemArea<C = AbstractContentItem> = {
    x1: number;
    x2: number;
    y1: number;
    y2: number;
    surface: number;
    side: 'left' | 'right' | 'top' | 'bottom' | '';
    contentItem: C;
};
/**
 * This is the baseclass that all content items inherit from.
 * Most methods provide a subset of what the sub-classes do.
 *
 * It also provides a number of functions for tree traversal
 *
 * @param {lm.LayoutManager} layoutManager
 * @param {item node configuration} config
 * @param {lm.item} parent
 *
 * @event stateChanged
 * @event beforeItemDestroyed
 * @event itemDestroyed
 * @event itemCreated
 * @event componentCreated
 * @event rowCreated
 * @event columnCreated
 * @event stackCreated
 *
 * @constructor
 */
export default abstract class AbstractContentItem extends EventEmitter {
    config: ItemConfig;
    type: string;
    contentItems: AbstractContentItem[];
    parent: AbstractContentItem | null;
    layoutManager: LayoutManager;
    element: JQuery<HTMLElement>;
    childElementContainer?: JQuery<HTMLElement>;
    componentName?: string;
    isInitialised: boolean;
    isMaximised: boolean;
    isRoot: boolean;
    isRow: boolean;
    isColumn: boolean;
    isStack: boolean;
    isComponent: boolean;
    tab?: Tab;
    private _pendingEventPropagations;
    private _throttledEvents;
    constructor(layoutManager: LayoutManager, config: ItemConfig, parent: AbstractContentItem | null, element: JQuery<HTMLElement>);
    /**
     * Set the size of the component and its children, called recursively
     *
     * @abstract
     */
    abstract setSize(width?: number, height?: number): void;
    /**
     * Calls a method recursively downwards on the tree
     *
     * @param functionName the name of the function to be called
     * @param functionArguments optional arguments that are passed to every function
     * @param bottomUp Call methods from bottom to top, defaults to false
     * @param skipSelf Don't invoke the method on the class that calls it, defaults to false
     */
    callDownwards<N extends 'setSize' | '_$destroy' | '_$init' | '_$show'>(functionName: N, functionArguments?: Parameters<AbstractContentItem[N]>, bottomUp?: boolean, skipSelf?: boolean): void;
    /**
     * Removes a child node (and its children) from the tree
     *
     * @param contentItem
     */
    removeChild(contentItem: AbstractContentItem, keepChild?: boolean): void;
    /**
     * Sets up the tree structure for the newly added child
     * The responsibility for the actual DOM manipulations lies
     * with the concrete item
     *
     * @param contentItem
     * @param index If omitted item will be appended
     */
    addChild(contentItem: AbstractContentItem | ItemConfig, index?: number): void;
    /**
     * Replaces oldChild with newChild. This used to use jQuery.replaceWith... which for
     * some reason removes all event listeners, so isn't really an option.
     *
     * @param oldChild
     * @param newChild
     */
    replaceChild(oldChild: AbstractContentItem, newChild: AbstractContentItem | ItemConfig, _$destroyOldChild?: boolean): void;
    /**
     * Convenience method.
     * Shorthand for this.parent.removeChild( this )
     */
    remove(): void;
    /**
     * Removes the component from the layout and creates a new
     * browser window with the component and its children inside
     */
    popout(): import("..").BrowserPopout | undefined;
    /**
     * Maximises the Item or minimises it if it is already maximised
     */
    toggleMaximise(e?: Event): void;
    /**
     * Selects the item if it is not already selected
     */
    select(): void;
    /**
     * De-selects the item if it is selected
     */
    deselect(): void;
    /**
     * Set this component's title
     * @param title
     */
    setTitle(title: string): void;
    /**
     * Checks whether a provided id is present
     * @param id
     * @returns isPresent
     */
    hasId(id: string): boolean | undefined;
    /**
     * Adds an id. Adds it as a string if the component doesn't
     * have an id yet or creates/uses an array
     * @param id
     */
    addId(id: string): void;
    /**
     * Removes an existing id. Throws an error
     * if the id is not present
     * @param id
     */
    removeId(id: string): void;
    /****************************************
     * SELECTOR
     ****************************************/
    getItemsByFilter(filter: (item: AbstractContentItem) => boolean): AbstractContentItem[];
    getItemsById(id: string): AbstractContentItem[];
    getItemsByType(type: string): AbstractContentItem[];
    getComponentsByName(componentName: string): unknown[];
    /****************************************
     * PACKAGE PRIVATE
     ****************************************/
    _$getItemsByProperty(key: keyof AbstractContentItem, value: string): AbstractContentItem[];
    _$setParent(parent: AbstractContentItem | null): void;
    _$highlightDropZone(x: number, y: number, area: ItemArea): void;
    _$onDrop(contentItem: AbstractContentItem, area: ItemArea): void;
    _$hide(): void;
    _$show(): void;
    _callOnActiveComponents(methodName: 'hide' | 'show'): void;
    /**
     * Destroys this item ands its children
     */
    _$destroy(): void;
    /**
     * Returns the area the component currently occupies in the format
     *
     * {
     *		x1: int
     *		x2: int
     *		y1: int
     *		y2: int
     *		contentItem: contentItem
     * }
     */
    _$getArea(element?: JQuery<HTMLElement>): ItemArea<this> | null;
    /**
     * The tree of content items is created in two steps: First all content items are instantiated,
     * then init is called recursively from top to bottem. This is the basic init function,
     * it can be used, extended or overwritten by the content items
     *
     * Its behaviour depends on the content item
     */
    _$init(): void;
    /**
     * Emit an event that bubbles up the item tree.
     *
     * @param name The name of the event
     */
    emitBubblingEvent(name: string): void;
    /**
     * Private method, creates all content items for this node at initialisation time
     * PLEASE NOTE, please see addChild for adding contentItems add runtime
     * @param   {configuration item node} config
     */
    _createContentItems(config: ItemConfig): void;
    /**
     * Extends an item configuration node with default settings
     * @param config
     * @returns extended config
     */
    _extendItemNode<TConfig extends ItemConfig>(config: TConfig): TConfig;
    /**
     * Called for every event on the item tree. Decides whether the event is a bubbling
     * event and propagates it to its parent
     *
     * @param name the name of the event
     * @param event
     */
    _propagateEvent(name: string, event: BubblingEvent): void;
    /**
     * All raw events bubble up to the root element. Some events that
     * are propagated to - and emitted by - the layoutManager however are
     * only string-based, batched and sanitized to make them more usable
     *
     * @param name the name of the event
     */
    _scheduleEventPropagationToLayoutManager(name: string, event: BubblingEvent): void;
    /**
     * Callback for events scheduled by _scheduleEventPropagationToLayoutManager
     *
     * @param name the name of the event
     */
    _propagateEventToLayoutManager(name: string, event: BubblingEvent): void;
}
//# sourceMappingURL=AbstractContentItem.d.ts.map