import * as React from 'react';
import { Filter, ResolvableContent } from '@nu-art/ts-common';
import { Adapter } from '../adapter/Adapter.js';
import { ComponentSync } from '../../core/ComponentSync.js';
import './TS_DropDown.scss';
import { UIProps_EditableItem } from '../../utils/EditableItem.js';
import { ComponentProps_Error } from '../types.js';
type State<ItemType> = ComponentProps_Error & {
    open?: boolean;
    adapter: Adapter<ItemType>;
    selected?: ItemType;
    hover?: ItemType;
    filterText?: string;
    dropDownRef: React.RefObject<HTMLDivElement>;
    treeContainerRef: React.RefObject<HTMLDivElement>;
    focusedItem?: ItemType;
    className?: string;
    hidePlaceholderOnOpen?: boolean;
    treeResizeObserver: ResizeObserver;
};
type StaticProps = {
    caret: {
        open: React.ReactNode;
        close: React.ReactNode;
    };
};
type InputEvent = React.KeyboardEvent | React.MouseEvent;
type Dropdown_Props<ItemType> = Partial<StaticProps> & ComponentProps_Error & {
    adapter: Adapter<ItemType> | ((filter?: string) => Adapter<ItemType>);
    placeholder?: string;
    inputValue?: string;
    noOptionsRenderer?: React.ReactNode | ((filter?: string) => React.ReactNode);
    onNoMatchingSelectionForString?: (filterText: string, matchingItems: ItemType[], e: React.KeyboardEvent) => any;
    selected?: ItemType;
    filter?: Filter<ItemType>;
    queryFilter?: (item: ItemType) => boolean;
    tabIndex?: number;
    innerRef?: React.RefObject<any>;
    id?: string;
    inputEventHandler?: (state: State<ItemType>, e: React.KeyboardEvent) => State<ItemType>;
    selectedItemRenderer?: (props?: ItemType) => React.ReactNode;
    showNothingWithoutFilterText?: boolean;
    disabled?: boolean;
    allowManualSelection?: boolean;
    className?: string;
    boundingParentSelector?: string;
    renderSearch?: (dropDown: TS_DropDown<ItemType>) => React.ReactNode;
    limitItems?: number;
    unselectLabel?: string;
    hidePlaceholderOnOpen?: boolean;
    onContextMenu?: (e: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
};
type Props_CanUnselect<ItemType> = {
    canUnselect: true;
    onSelected: (selected?: ItemType) => void;
};
type Props_CanNotUnselect<ItemType> = {
    canUnselect?: false;
    onSelected: (selected: ItemType) => void;
};
type Props_CanUnselect_NonMandatory<ItemType> = {
    canUnselect: true;
    onSelected?: (selected?: ItemType) => void;
};
type Props_CanNotUnselect_NonMandatory<ItemType> = {
    canUnselect?: false;
    onSelected?: (selected: ItemType) => void;
};
export type Props_DropDown<ItemType> = (Props_CanUnselect<ItemType> | Props_CanNotUnselect<ItemType>) & Dropdown_Props<ItemType>;
export type MandatoryProps_TS_DropDown<ItemType> = Dropdown_Props<ItemType>;
type BasePartialProps_DropDown<T> = {
    className?: string;
    inputValue?: string;
    placeholder?: string;
    onNoMatchingSelectionForString?: (filterText: string, matchingItems: T[], e: React.KeyboardEvent) => Promise<void> | void;
    mapper?: (item: T) => string[];
    renderer?: (item: T) => React.ReactElement;
    queryFilter?: (item: T) => boolean;
    disabled?: boolean;
    ifNoneShowAll?: boolean;
};
export type PartialProps_DropDown<T> = BasePartialProps_DropDown<T> & ComponentProps_Error & (Props_CanUnselect<T> | Props_CanNotUnselect<T>) & {
    selected?: T;
};
type EditableDropDownProps<ItemType, EditableType extends {} = any, ValueType extends EditableType[keyof EditableType] = EditableType[keyof EditableType]> = BasePartialProps_DropDown<ItemType> & UIProps_EditableItem<EditableType, keyof EditableType, ValueType> & ComponentProps_Error & (Props_CanUnselect_NonMandatory<ItemType> | Props_CanNotUnselect_NonMandatory<ItemType>);
export declare class TS_DropDown<ItemType> extends ComponentSync<Props_DropDown<ItemType>, State<ItemType>> {
    static readonly prepareEditable: <T, EditableType extends {} = any, ValueType extends EditableType[keyof EditableType] = EditableType[keyof EditableType]>(mandatoryProps: ResolvableContent<MandatoryProps_TS_DropDown<T>>) => (props: EditableDropDownProps<T, EditableType, ValueType>) => import("react/jsx-runtime").JSX.Element;
    static readonly prepareSelectable: <T = any>(mandatoryProps: ResolvableContent<MandatoryProps_TS_DropDown<T>>) => (props: PartialProps_DropDown<T>) => import("react/jsx-runtime").JSX.Element;
    static readonly prepare: <T = any>(mandatoryProps: ResolvableContent<MandatoryProps_TS_DropDown<T>>) => {
        editable: (props: EditableDropDownProps<T, any, any>) => import("react/jsx-runtime").JSX.Element;
        selectable: (props: PartialProps_DropDown<T>) => import("react/jsx-runtime").JSX.Element;
    };
    static defaultRenderSearch: (dropDown: TS_DropDown<any>) => import("react/jsx-runtime").JSX.Element;
    static defaultProps: {
        renderSearch: (dropDown: TS_DropDown<any>) => import("react/jsx-runtime").JSX.Element;
    };
    constructor(props: Props_DropDown<ItemType>);
    protected deriveStateFromProps(nextProps: Props_DropDown<ItemType>, state?: Partial<State<ItemType>>): State<ItemType>;
    onTreeResize: () => void;
    componentDidUpdate(): void;
    private getBoundingParent;
    private closeList;
    onSelected: (item?: ItemType, e?: InputEvent) => void;
    private inputKeyEventHandler;
    private createAdapter;
    private getChildrenContainerMaxHeight;
    private getChildrenContainerPosX;
    private getChildrenContainerPosY;
    private getChildrenContainerWidth;
    render(): import("react/jsx-runtime").JSX.Element;
    private renderHeader;
    private renderTree;
    private renderSelectedItem;
    private renderSelectedOrFilterInput;
    private addKeyboardListener;
    private removeKeyboardListener;
    keyboardEventHandler: (e: KeyboardEvent) => void | null;
}
export {};