import { JSXInterface } from '../../jsx';
import { PropertyValues, TapEvent } from '@refinitiv-ui/core';
import { CollectionComposer } from '@refinitiv-ui/utils/collection.js';
import { List } from '../../list/index.js';
import type { TreeData, TreeDataItem, TreeFilter } from '../helpers/types';
import { TreeManager, TreeManagerMode } from '../managers/tree-manager.js';
import './tree-item.js';
/**
 * Displays a tree structure
 * to be used for menus and group selections
 *
 * @fires value-changed - Fired when the user commits a value change. The event is not triggered if `value` property is changed programmatically.
 * @fires expanded-changed - Fired when the user expands or collapses item. The event is not triggered if `expanded` property is changed programmatically.
 *
 * @attr {boolean} [stateless=false] - Disable selections
 * @prop {boolean} [stateless=false] - Disable selections
 */
export declare class Tree<T extends TreeDataItem = TreeDataItem> extends List<T> {
    /**
     * Element version number
     * @returns version number
     */
    static get version(): string;
    protected readonly defaultRole: string | null;
    private _manager;
    /**
     * Tree manager used for item manipulation
     */
    get manager(): TreeManager<T>;
    /**
     * Allows multiple items to be selected
     */
    multiple: boolean;
    /**
     * Breaks the relationship when multiple
     * selection mode is enabled
     */
    noRelation: boolean;
    /**
     * Query string applied to tree
     */
    query: string;
    /**
     * Custom filter for static data
     * @type {TreeFilter<T> | null}
     */
    filter: TreeFilter<T> | null;
    /**
     * Renderer used for generating tree items
     */
    renderer: (item: T, composer: CollectionComposer<T>, element?: HTMLElement | undefined) => HTMLElement;
    /**
     * Expands all groups
     * @returns {void}
     */
    expandAll(): void;
    /**
     * Collapses all groups
     * @returns {void}
     */
    collapseAll(): void;
    /**
     * Checks all editable items
     * @returns {void}
     */
    checkAll(): void;
    /**
     * Unchecks all editable items
     * @returns {void}
     */
    uncheckAll(): void;
    /**
     * @override
     * @ignore
     */
    selectItem(item: T): boolean;
    /**
     * Force uncheck item when item is locked
     * @param item Original data item
     * @returns {void}
     */
    protected forceUncheckItem(item: T): void;
    /**
     * Dispatches an event, detailing which item has recently changed it's expanded state.
     * @param item Data item of which the expanded property changed
     * @returns {void}
     */
    protected dispatchExpandedChangedEvent(item: T): void;
    /**
     * Handles tap event when composed path contains
     * an element with an `expand-toggle` attribute.
     * @param event Tap event to try and handle
     * @returns True or False depending if the event was handled
     */
    protected handleExpandCollapse(event: TapEvent): boolean;
    /**
     * @override
     */
    protected onTap(event: TapEvent): void;
    /**
     * @override
     */
    protected onKeyDown(event: KeyboardEvent): void;
    /**
     * Performs left arrow keyboard action,
     * collapsing a group item if possible.
     * @returns {void}
     */
    protected left(): void;
    /**
     * Performs right arrow keyboard action,
     * expanding a group item if possible.
     * @returns {void}
     */
    protected right(): void;
    /**
     * Toggles the expanded state of an item.
     * Executed when a user taps on an item to expand/collapse the group.
     * @param item Original data item
     * @returns {void}
     */
    protected toggleExpandedState(item: T): void;
    /**
     * @override
     */
    protected queryItems(engine: (item: T, composer: CollectionComposer<T>) => boolean): readonly T[];
    /**
     * @override
     */
    protected queryItemsByPropertyValue<K extends keyof T>(property: K, value: T[K]): readonly T[];
    /**
     * @override
     */
    protected willUpdate(changeProperties: PropertyValues): void;
    /**
     * Filter the internal items by query changes items' hidden state
     * @returns {void}
     */
    protected filterItems(): void;
    /**
     * Utility method
     * Adds descendants for each item passed
     * @param items List of child items
     * @returns {void}
     */
    protected addItemDescendantsToRender(items: T[]): void;
    /**
     * Utility method
     * Add nested children of item list
     * @param items List of items
     * @param excludeItems List of exclude items
     * @param [includeHidden=false] Include hidden items
     * @returns {void}
     */
    protected addNestedItemsToRender(items: readonly T[], excludeItems: readonly T[], includeHidden?: boolean): void;
    /**
     * Utility method
     * Adds ancestors for each item passed and expand
     * @param items List of child items
     * @returns {void}
     */
    protected addExpandedAncestorsToRender(items: T[]): void;
    /**
     * Utility method
     * Adds parent and expands
     * @param ancestor parent item
     * @returns {void}
     */
    protected addExpandedAncestorToRender(ancestor: T): void;
    /**
     * Selected items in tree
     * @override
     * @type {string[]}
     * @default []
     */
    get values(): string[];
    set values(values: string[]);
    /**
     * Data object to be used for creating tree
     * @override
     * @type {TreeData<T>}
     */
    get data(): TreeData<T>;
    set data(data: TreeData<T>);
    /**
     * @override
     */
    protected get renderItems(): readonly T[];
    /**
     * Mode to use in the tree manager
     */
    protected get mode(): TreeManagerMode;
}
declare global {
    interface HTMLElementTagNameMap {
        'ef-tree': Tree;
    }
}

declare global {
  interface HTMLElementTagNameMap {
    'ef-tree': Tree;
  }

  namespace JSX {
    interface IntrinsicElements {
      'ef-tree': Partial<Tree> | JSXInterface.HTMLAttributes<Tree>;
    }
  }
}

export {};