import { JSXInterface } from '../jsx';
import { CSSResultGroup, TemplateResult } from '@refinitiv-ui/core';
import '@refinitiv-ui/phrasebook/locale/en/tree-select.js';
import { TranslateDirective } from '@refinitiv-ui/translate';
import { TimeoutTaskRunner } from '@refinitiv-ui/utils/async.js';
import { CollectionComposer } from '@refinitiv-ui/utils/collection.js';
import '../button/index.js';
import '../checkbox/index.js';
import { ComboBox, ComboBoxFilter as TreeSelectFilter } from '../combo-box/index.js';
import type { CheckChangedEvent } from '../events';
import '../icon/index.js';
import type { Overlay } from '../overlay';
import '../pill/index.js';
import { TreeRenderer as TreeSelectRenderer, createTreeRenderer as createTreeSelectRenderer } from '../tree/index.js';
import type { Tree } from '../tree/index.js';
import { TreeManager, TreeManagerMode } from '../tree/managers/tree-manager.js';
import type { TreeSelectData, TreeSelectDataItem } from './helpers/types';
export { TreeSelectRenderer, createTreeSelectRenderer };
export type { TreeSelectFilter, TreeSelectDataItem, TreeSelectData };
/**
 * Dropdown control that allows selection from the tree list
 *
 * @prop {TreeSelectFilter<T> | null} [filter=createDefaultFilter<T>(this)] - Custom filter for static data. Set this to null when data is filtered externally, eg XHR
 * @attr {number} [query-debounce-rate] - Control query rate in milliseconds
 * @prop {number} [queryDebounceRate] - Control query rate in milliseconds
 * @attr {boolean} [opened=false] - Set dropdown to open
 * @prop {boolean} [opened=false] - Set dropdown to open
 * @attr {string} placeholder - Set placeholder text
 * @prop {string} [placeholder=""] - Set placeholder text
 * @attr {boolean} clears - Show clears button
 * @prop {boolean} [clears=false] - Show clears button
 * @prop {TreeSelectData[]} [data=[]] - Data object to be used for creating tree
 * @fires confirm - Fired when the user closes a popup by confirming the new selection.
 * @fires cancel - Fired when the user closes a popup by cancelling the new selection.
 * @fires value-changed - Fired when the user commits a value change. The event is not triggered if `value` property is changed programmatically.
 * @fires query-changed - Fired when the user changes value in the input to change a query word. If `query-debounce-rate` is set, this event will be triggered after debounce completion. The event is not triggered if `query` property is changed programmatically.
 * @fires opened-changed - Fired when the user opens or closes control's popup. The event is not triggered if `opened` property is changed programmatically.
 */
export declare class TreeSelect extends ComboBox<TreeSelectDataItem> {
    /**
     * Element version number
     * @returns version number
     */
    static get version(): string;
    constructor();
    static get styles(): CSSResultGroup;
    /**
     * Tracks the number of filter matches
     *
     * Only needed if internal filtering is unused
     */
    filterCount: number;
    /**
     * Memoized selection and expansion stats
     * Used for displaying counts and calculating control visibility/content
     */
    protected memo: {
        selected: number;
        selectable: number;
        expanded: number;
        expandable: number;
    };
    /**
     * Extracted values from {@link this.checkedGroupedItems}
     */
    protected pillsData: Readonly<TreeSelectDataItem[]>;
    /**
     * Cache old selection timestamps for revert selected timestamps when cancel selection
     */
    protected oldSelection: Map<string, number | undefined>;
    /**
     * Are there pills visible
     */
    protected hasPills: boolean;
    /**
     * Store references to items selected and visible at point of selection filter being applied
     * Allow for items to be removed from the selection, but still be visible
     */
    protected editSelectionItems: Set<TreeSelectDataItem>;
    /**
     * Composer used for live changes
     */
    protected composer: CollectionComposer<TreeSelectDataItem>;
    protected _treeManager: TreeManager<TreeSelectDataItem>;
    /**
     * Tree manager used for item manipulation
     * @type {TreeManager <TreeSelectDataItem>}
     */
    get treeManager(): TreeManager<TreeSelectDataItem>;
    /**
     * Modification updates are called a lot
     *
     * This throttles the memo updates to reduce lookups
     */
    protected memoUpdateThrottle: TimeoutTaskRunner;
    /**
     * Used for translations
     * Beware tPromise!: TranslatePromise from Combo-box. It's different type from this translation.
     */
    protected t: TranslateDirective;
    /**
     * Breaks the relationship when multiple
     * selection mode is enabled
     */
    noRelation: boolean;
    /**
     * Should the control show pills
     */
    showPills: boolean;
    private _values;
    /**
     * Returns a values collection of the currently
     * selected item values
     * @type {string[]}
     * @default []
     */
    get values(): string[];
    set values(values: string[]);
    /**
     * Update composer values.
     * @param newValues new values
     * @returns {void}
     */
    protected updateComposerValues(newValues: string[]): void;
    /**
     * Renderer used to render tree item elements
     */
    renderer: (item: import("../tree/index.js").TreeDataItem, composer: CollectionComposer<import("../tree/index.js").TreeDataItem>, element?: HTMLElement | undefined) => HTMLElement;
    private _max;
    /**
     * Set maximum number of selected items
     * @param value max value
     * @default -
     */
    set max(value: string | null);
    /**
     * Set maximum number of selected items
     * @returns max value
     */
    get max(): string | null;
    /**
     * Internal reference to popup element
     */
    protected popupEl?: Overlay;
    /**
     * Internal reference to tree element
     */
    protected treeEl?: Tree;
    /**
     * Set resolved data
     * @param value resolved data
     */
    protected set resolvedData(value: TreeSelectDataItem[]);
    protected get resolvedData(): TreeSelectDataItem[];
    /**
     * The the values from composer ignoring freeTextValue
     * @override
     */
    protected get composerValues(): string[];
    /**
     * Provide list of currently selected items
     */
    protected get selection(): TreeSelectDataItem[];
    /**
     * Get a list of selected item labels
     * @returns Has selection
     * @override
     */
    protected get selectedLabels(): string[];
    /**
     * Returns memoized selected state
     * @returns Has selection
     */
    protected get hasActiveSelection(): boolean;
    /**
     * Returns memoized selectable state
     * @returns Has selectable
     */
    protected get hasSelectable(): boolean;
    /**
     * Returns memoized all selected count
     * @returns Is all selected
     */
    protected get isAllSelected(): boolean;
    /**
     * Returns memoized expansion state
     * @returns Are all expanded
     */
    protected get hasExpansion(): boolean;
    /**
     * Determines if the expansion controls should be displayed
     *
     * @returns Control visible state
     */
    protected get expansionControlVisible(): boolean;
    /**
     * Determine if the selection filter is active
     * @returns Selection filter on/off
     */
    protected get selectionFilterState(): boolean;
    /**
     * Mode to use in the tree manager
     */
    protected get mode(): TreeManagerMode;
    /**
     * Get a list of selected items.
     * If all leaves are selected, a parent becomes selected
     * If mode is INDEPENDENT, grouping is not applied
     */
    protected get checkedGroupedItems(): readonly TreeSelectDataItem[];
    /**
     * Determines whether the "Done" button element should be disabled,
     * based on the current state and certain conditions.
     * @returns {boolean} True if the "Done" button should be disabled, false otherwise.
     */
    protected get isConfirmDisabled(): boolean;
    /**
     * Commit the current selection applying it to `values` property.
     * @return {void}
     */
    commit(): void;
    /**
     * Persist the current selection applying it to @link TreeSelect.values}.
     * @param shouldNotify Whether to notify the change with `value-changed` event or not.
     * @returns {void}
     */
    private persistSelection;
    /**
     * Revert modified selection to old values. Run on Esc or Cancel
     * @returns {void}
     */
    protected revertModifiedSelection(): void;
    /**
     * Revert all selected timestamps to the previous state which affect to item sorting
     * @returns {void}
     */
    protected revertSelectionTimestamps(): void;
    /**
     * Update memoized track
     *
     * Update states for expansion and selection
     *
     * @returns {void}
     */
    protected updateMemo(): void;
    /**
     * Utility method - closes and resets changes such as query
     * @returns {void}
     */
    protected closeAndReset(): void;
    /**
     * Save the current selection
     * @returns {void}
     */
    protected save(): void;
    /**
     * Discard the current selection
     * @returns {void}
     */
    protected cancel(): void;
    /**
     * Toggle tree level expansion action
     * @returns {void}
     */
    protected expansionToggleClickHandler(): void;
    /**
     * Toggle Selection of all tree items
     * @param event checked-change event
     * @returns {void}
     */
    protected selectionToggleHandler(event: CheckChangedEvent): void;
    /**
     * Remove selection filter
     * @returns {void}
     */
    protected fullClickHandler(): void;
    /**
     * Apply selection filter
     * @returns {void}
     */
    protected selectedClickHandler(): void;
    /**
     * Apply the selection filter by entering edit selection mode
     * @returns {void}
     */
    protected enterEditSelection(): void;
    /**
     * Remove selection filtering by exiting edit selection mode
     * @returns {void}
     */
    protected exitEditSelection(): void;
    /**
     * Executed when the popup is fully opened
     * @returns {void}
     */
    protected onPopupOpened(): void;
    /**
     * Clear selection filter
     * @returns {void}
     */
    protected clearSelectionFilter(): void;
    /**
     * Executed when the popup is fully closed
     * @returns {void}
     */
    protected onPopupClosed(): 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: TreeSelectDataItem[]): void;
    /**
     * Utility method
     * Add nested children of item list
     * @param items List of items
     * @param excludeItems List of exclude items
     * @returns {void}
     */
    protected addNestedItemsToRender(items: readonly TreeSelectDataItem[], excludeItems: readonly TreeSelectDataItem[]): void;
    /**
     * Utility method
     * Adds ancestors for each item passed and expand
     * @param items List of child items
     * @returns {void}
     */
    protected addExpandedAncestorsToRender(items: TreeSelectDataItem[]): void;
    /**
     * Utility method
     * Adds parent and expands
     * @param ancestor parent item
     * @returns {void}
     */
    protected addExpandedAncestorToRender(ancestor: TreeSelectDataItem): void;
    /**
     * Reacts to pill removal by de-selecting the related item
     * @param event Event containing the pill item
     *
     * @returns {void}
     */
    protected onPillRemoved(event: CustomEvent): void;
    /**
     * Handles key input
     * @param event Key down event object
     * @returns {void}
     */
    protected onKeyDown(event: KeyboardEvent): void;
    /**
     * Navigates up the list.
     * Opens the list if closed.
     * @param event keyboard event
     * @returns {void}
     */
    protected up(event: KeyboardEvent): void;
    /**
     * Navigates down the list.
     * Opens the list if closed.
     * @param event keyboard event
     * @returns {void}
     */
    protected down(event: KeyboardEvent): void;
    /**
     * Make sure that after up/down keys the focus gracefully moves to selection area
     * so the user can then use left/right/Enter keys for keyboard navigation
     * @returns {void}
     */
    private focusOnSelectionArea;
    /**
     * Adds a throttled update for pills and memo
     * @returns {void}
     */
    protected modificationUpdate(): void;
    /**
     * Update pills if {@link TreeSelect.showPills} showPills is applied
     *
     * @returns {void}
     */
    protected updatePills(): void;
    /**
     * Queries the composer for data items. Uses Infinity depth
     * @param engine Composer query engine
     * @returns Collection of matched items
     * @override
     */
    protected queryItems(engine: (item: TreeSelectDataItem, composer: CollectionComposer<TreeSelectDataItem>) => boolean): readonly TreeSelectDataItem[];
    /**
     * Queries the composer for data items,
     * matching by property value. Uses Infinity depth
     * @param property Property name to query
     * @param value Property value to match against
     * @returns Collection of matched items
     * @override
     */
    protected queryItemsByPropertyValue<K extends keyof TreeSelectDataItem>(property: K, value: TreeSelectDataItem[K]): readonly TreeSelectDataItem[];
    /**
     * Filter template
     * @returns Render template
     */
    protected get filtersTemplate(): TemplateResult;
    /**
     * Tree control template
     * @returns Render template
     */
    protected get treeControlsTemplate(): TemplateResult;
    /**
     * Conditional filter matches template
     * @returns Render template
     */
    protected get matchCountTemplate(): TemplateResult;
    /**
     * Commit controls template
     * @returns Render template
     */
    protected get commitControlsTemplate(): TemplateResult;
    /**
     * Pills template
     * @returns Render template
     */
    protected get pillsTemplate(): TemplateResult | undefined;
    /**
     * Returns template for popup
     * Lazy loads the popup
     * @returns Popup template or undefined
     */
    protected get popupTemplate(): TemplateResult | undefined;
}
declare global {
    interface HTMLElementTagNameMap {
        'ef-tree-select': TreeSelect;
    }
}

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

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

export {};