/**
 * @license
 *-------------------------------------------------------------------------------------------
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the package root for more information
 *-------------------------------------------------------------------------------------------
 */
import { ComboBoxFilterChangeEvent as ComboBoxFilterChangeEvent_2 } from './ComboBoxProps';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { DefineComponent } from 'vue';
import { DropDownListChangeEvent as DropDownListChangeEvent_2 } from './DropDownListProps';
import { DropDownsPopupSettings as DropDownsPopupSettings_2 } from './../common/settings';
import { DropDownsPopupSettings as DropDownsPopupSettings_3 } from '..';
import { ExtractPropTypes } from 'vue';
import { FormComponentProps } from '@progress/kendo-vue-common';
import { FormComponentValidity } from '@progress/kendo-vue-common';
import { ItemRenderProps } from '@progress/kendo-vue-treeview';
import { PopupAnimation } from '@progress/kendo-vue-popup';
import { PopupSettings } from '@progress/kendo-vue-popup';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { SVGIcon } from '@progress/kendo-svg-icons';
import { TreeViewExpandChangeEvent } from '@progress/kendo-vue-treeview';
import { TreeViewItemClickEvent } from '@progress/kendo-vue-treeview';
import { VirtualizationSettings as VirtualizationSettings_2 } from './../common/settings';

/**
 * @hidden
 */
declare enum ActiveDescendant {
    PopupList = 0,
    TagsList = 1
}

/**
 * @hidden
 */
export declare const AutoComplete: DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
defaultValue: {
type: PropType<string>;
default: any;
};
name: PropType<string>;
modelValue: {
type: PropType<string>;
default: any;
};
value: {
type: PropType<string>;
default: any;
};
label: {
type: PropType<string>;
};
placeholder: PropType<string>;
required: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: {
type: PropType<string>;
default: any;
};
tabIndex: {
type: PropType<number>;
default: any;
};
readonly: PropType<boolean>;
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
header: PropType<any>;
footer: PropType<any>;
suggest: {
type: PropType<string | boolean>;
default: boolean;
};
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
inputAttributes: PropType<Object>;
}>, {
inputRef: Ref<any, any>;
kendoAnchorRef: Ref<any, any>;
}, {
hasMounted: boolean;
currentText: string;
currentValue: string;
currentFocused: boolean;
currentOpened: boolean;
focusedItem: any;
searchState: {
word: string;
last: string;
};
valueDuringOnChange: {};
suggested: string;
group: any;
isScrolling: boolean;
popupWidth: any;
itemHeight: number;
}, {
spanClassNames(): {
'k-floating-label-container': boolean;
'k-focus': any;
'k-empty': boolean;
'k-invalid': boolean;
'k-rtl': boolean;
};
}, {
focus(): void;
computedValue(): any;
primitiveValue(): any;
validity(): FormComponentValidity;
handleItemSelect(index: number, state: AutoCompleteInternalState): void;
itemFocus(index: number, state: AutoCompleteInternalState): void;
togglePopup(state: InternalState): void;
onNavigate(state: AutoCompleteInternalState, keyCode: number): void;
/**
* @hidden
*/
applyInputValue(value: string, state: AutoCompleteInternalState, eventKey?: number): void;
setValidity(): void;
handleItemClick(index: number, event: any): void;
onChangeHandler(event: any): void;
clearButtonClick(event: any): void;
onInputKeyDown(event: any): void;
handleBlur(event: any): void;
triggerOnChange(newValue: string, state: AutoCompleteInternalState, eventArgs?: any): void;
triggerOnSelect(state: AutoCompleteInternalState, eventArgs?: any): void;
applyState(state: AutoCompleteInternalState): void;
suggestValue(value: string): void;
focusedIndex(value?: string): any;
repositionPopup(): void;
onScroll(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
defaultValue: {
type: PropType<string>;
default: any;
};
name: PropType<string>;
modelValue: {
type: PropType<string>;
default: any;
};
value: {
type: PropType<string>;
default: any;
};
label: {
type: PropType<string>;
};
placeholder: PropType<string>;
required: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: {
type: PropType<string>;
default: any;
};
tabIndex: {
type: PropType<number>;
default: any;
};
readonly: PropType<boolean>;
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: (ObjectConstructor | StringConstructor | FunctionConstructor)[];
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
header: PropType<any>;
footer: PropType<any>;
suggest: {
type: PropType<string | boolean>;
default: boolean;
};
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
inputAttributes: PropType<Object>;
}>> & Readonly<{}>, {
required: boolean;
value: string;
ariaLabel: string;
tabIndex: number;
size: string;
rounded: string;
fillMode: string;
dir: string;
defaultValue: string;
opened: boolean;
popupSettings: DropDownsPopupSettings_2;
modelValue: string;
valid: boolean;
validationMessage: string;
validityStyles: boolean;
suggest: string | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the object of the `blur` AutoComplete event.
 */
export declare interface AutoCompleteBlurEvent extends BlurEvent {
}

/**
 * Represents the object of the `change` AutoComplete event.
 */
export declare interface AutoCompleteChangeEvent extends ChangeEvent {
    /**
     * The selected Suggestion object.
     */
    suggestion?: Suggestion;
    /**
     * Represents the selected item.
     */
    item?: any;
}

/**
 * Represents the object of the `select` AutoComplete event.
 */
export declare interface AutoCompleteChangeEvent extends ChangeEvent {
    /**
     * Represents the selected item.
     */
    item?: any;
}

/**
 * Represents the object of the `close` AutoComplete event.
 */
export declare interface AutoCompleteCloseEvent extends CloseEvent_2 {
}

/**
 * Represents the object of the `focus` AutoComplete event.
 */
export declare interface AutoCompleteFocusEvent extends FocusEvent_2 {
}

/**
 * @hidden
 */
declare interface AutoCompleteInternalState extends InternalState {
    data: AutoCompleteState;
}

/**
 * Represents the object of the `open` AutoComplete event.
 */
export declare interface AutoCompleteOpenEvent extends OpenEvent {
}

/**
 * Represents the props of the [Kendo UI for Vue AutoComplete component]({% slug overview_autocomplete %}).
 */
export declare interface AutoCompleteProps extends FormComponentProps {
    /**
     * Sets the data of the AutoComplete ([more information and example]({% slug binding_autocomplete %})).
     */
    dataItems?: any[];
    /**
     * Sets the opened and closed state of the AutoComplete.
     */
    opened?: boolean;
    /**
     * Sets the v-model value of the AutoComplete ([more information and example]({% slug binding_autocomplete %})).
     */
    modelValue?: string;
    /**
     * Sets the value of the AutoComplete ([more information and example]({% slug binding_autocomplete %})).
     */
    value?: string;
    /**
     * Sets the default value of the AutoComplete. Similar to the native `input` HTML element.
     */
    defaultValue?: string;
    /**
     * The hint that is displayed when the AutoComplete is empty.
     */
    placeholder?: string;
    /**
     * Sets the read-only state of the AutoComplete.
     */
    readonly?: boolean;
    /**
     * Enables the auto-completion of the text based on the first data item ([see example]({% slug suggestions_autocomplete %})).
     */
    suggest?: boolean | string;
    /**
     * Sets the disabled state of the AutoComplete.
     */
    disabled?: boolean;
    /**
     * Represents the `dir` HTML attribute.
     */
    dir?: string;
    /**
     * Sets the loading state of the AutoComplete ([see example]({% slug filtering_autocomplete %}#toc-basic-configuration)).
     */
    loading?: boolean;
    /**
     * Specifies the `tabIndex` of the AutoComplete.
     */
    tabIndex?: number;
    /**
     * Specifies the `accessKey` of the AutoComplete.
     */
    accessKey?: string;
    /**
     * Sets the data item field that represents the item text ([see example]({% slug binding_autocomplete %}#toc-datasets-of-objects)). If the data contains only primitive values, do not define it.
     */
    textField?: string;
    /**
     * Renders a floating label for the AutoComplete.
     */
    label?: string;
    /**
     * Configures the popup of the AutoComplete.
     */
    popupSettings?: DropDownsPopupSettings;
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
     * For example these elements could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Defines the [aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label) attribute of the component.
     */
    ariaLabel?: string;
    /**
     * If set, the AutoComplete will use it to get the focused item index.
     *
     * Default functionality returns the first item which starts with the input text.
     *
     * @example
     * ```jsx-no-run
     * const focusedItemIndex = (data, inputText, textField) => {
     *     let text = inputText.toLowerCase();
     *     return data.findIndex(item =>
     *         String(textField ? item[textField] : item).toLowerCase().includes(text));
     * };
     *
     * <AutoComplete focusedItemIndex={focusedItemIndex} />
     * ```
     */
    focusedItemIndex?: (data: any, inputText: string, textField?: string) => number;
    /**
     * Fires each time the popup of the AutoComplete is about to open.
     */
    onOpen?: (event: AutoCompleteOpenEvent) => void;
    /**
     * Fires each time the popup of the AutoComplete is about to close.
     */
    onClose?: (event: AutoCompleteCloseEvent) => void;
    /**
     * Fires each time the user focuses the AutoComplete.
     */
    onFocus?: (event: AutoCompleteFocusEvent) => void;
    /**
     * Fires each time the AutoComplete gets blurred.
     */
    onBlur?: (event: AutoCompleteBlurEvent) => void;
    /**
     * Fires each time the value of the AutoComplete is about to change ([more information and example]({% slug binding_autocomplete %})).
     */
    onChange?: (event: AutoCompleteChangeEvent) => void;
    /**
     * Fires when an AutoComplete list item is about to be rendered ([see example]({% slug customrendering_autocomplete %}#toc-items)). Used to override the default appearance of the list items.
     */
    itemRender?: any;
    /**
     * Fires when the element which indicates no data in the popup is about to be rendered ([see example]({% slug customrendering_autocomplete %}#toc-no-data)). Used to override the default appearance of the element.
     */
    listNoDataRender?: any;
    /**
     * Sets the header component of the AutoComplete ([see example]({% slug customrendering_autocomplete %}#toc-headers-and-footers)).
     */
    header?: any;
    /**
     * Sets the footer component of the AutoComplete ([see example]({% slug customrendering_autocomplete %}#toc-headers-and-footers)).
     */
    footer?: any;
    /**
     * Configures the `size` of the AutoComnplete.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - null&mdash;Does not set a size `class`.
     *
     * @default `medium`
     */
    size?: null | 'small' | 'medium' | 'large' | string;
    /**
     * Configures the `roundness` of the AutoComnplete.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - full
     * - null&mdash;Does not set a rounded `class`.
     *
     * @default `medium`
     */
    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `fillMode` of the AutoComnplete.
     *
     * The available options are:
     * - solid
     * - outline
     * - flat
     * - link
     * - null&mdash;Does not set a fillMode `class`.
     *
     * @default `solid`
     */
    fillMode?: null | 'solid' | 'outline' | 'flat' | string;
    /**
     * Sets the data item field that represents the start of a group. Applicable to objects data.
     */
    groupField?: string;
    /**
     * Fires when a AutoComplete group header item is about to be rendered. Used to override the default appearance of the group's headers.
     */
    groupHeaderItemRender?: any;
    /**
     * Fires when a AutoComplete sticky group header item is about to be rendered. Used to override the default appearance of the sticky group header of the component.
     */
    groupStickyHeaderItemRender?: any;
    /**
     * Sets the built-in HTML attributes of the inner focusable input element.
     * Attributes which are essential for certain component functionalities cannot be changed.
     */
    inputAttributes?: Object;
}

/**
 * @hidden
 */
declare interface AutoCompleteState extends DropDownStateBase {
    focusedItem?: any;
    value?: string;
    currentValue?: string;
}

/**
 * @hidden
 */
declare interface AutoCompleteState extends DropDownStateBase {
    anchor: string;
    typingTimeout: any;
    base: any;
    input: any;
    element: any;
    inputId: string;
    virtualHasChanged: any;
    prevOpened: any;
    prevCurrentOpened: any;
    prevData: any;
    prevFocusedItem: any;
    inputRef: any;
    listRef: any;
    filterInputRef: any;
    scrollElementRef: any;
    scrollerRef: any;
    kendoAnchorRef: any;
}

/**
 * @hidden
 */
declare interface BlurEvent extends DropdownEvent {
}

/**
 * @hidden
 */
declare interface ChangeEvent extends DropdownEvent {
    /**
     * The current value of the component.
     */
    value: any;
}

/**
 * @hidden
 */
declare interface CloseEvent_2 extends DropdownEvent {
}

/**
 * @hidden
 */
export declare const ComboBox: DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
dataItemKey: {
type: PropType<string>;
};
defaultValue: {
type: PropType<any>;
default: any;
};
name: StringConstructor;
modelValue: {
type: PropType<any>;
default: any;
};
value: {
type: PropType<any>;
default: any;
};
label: {
type: PropType<string>;
};
placeholder: PropType<string>;
required: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconClassName: PropType<string>;
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: {
type: PropType<string>;
default: any;
};
tabIndex: {
type: PropType<number>;
default: number;
};
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
className: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: PropType<any>;
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
header: PropType<any>;
footer: PropType<any>;
filterable: PropType<boolean>;
filter: {
type: PropType<string>;
default: any;
};
virtual: {
type: PropType<VirtualizationSettings_2>;
default: any;
};
suggest: {
type: PropType<boolean>;
default: boolean;
};
allowCustom: {
type: PropType<boolean>;
default: boolean;
};
clearButton: {
type: PropType<boolean>;
default: boolean;
};
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
valueField: PropType<string>;
valuePrimitive: PropType<boolean>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
onFilterchange: PropType<(event: ComboBoxFilterChangeEvent_2) => void>;
inputAttributes: PropType<Object>;
}>, {
inputRef: Ref<any, any>;
elementRef: Ref<any, any>;
kendoAnchorRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
hasMounted: boolean;
currentText: string;
currentValue: string;
currentFocused: boolean;
currentOpened: boolean;
searchState: {
word: string;
last: string;
};
_skipFocusEvent: boolean;
valueDuringOnChange: {};
_navigated: boolean;
suggested: string;
group: any;
isScrolling: boolean;
itemHeight: number;
state: any;
popupWidth: any;
windowWidth: number;
}, {
index(): number;
spanClassNames(): object;
isOpen(): boolean;
animationStyles(): object | undefined;
classNameAdaptive(): string;
adaptiveState(): any;
}, {
focus(): void;
computedValue(): any;
findByFieldValue(field: string, value: string): any;
primitiveValue(): any;
validity(): FormComponentValidity;
handleItemSelect(index: number, state: InternalState): void;
onNavigate(state: InternalState, keyCode: number): void;
toggleBtnClick(event: MouseEvent): void;
applyValueOnEnter(value: string, state: InternalState): any;
applyValueOnRejectSuggestions(text: string, state: InternalState): any;
selectFocusedItem(text: string, state: InternalState): any;
handleItemClick(index: number, event: any): void;
handleFocus(event: any): void;
handleBlur(event: any): void;
onInputKeyDown(event: any): void;
inputOnChange(event: any): void;
clearButtonClick(event: any): void;
getFocusedIndex(): number;
suggestValue(value?: string): void;
setValidity(): void;
triggerOnChange(item: any, state: InternalState): void;
applyState(state: InternalState): void;
calculateMedia(entries: ResizeObserverEntry[]): void;
repositionPopup(): void;
onScroll(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
filterchange: any;
pagechange: any;
change: any;
focus: any;
blur: any;
open: any;
close: any;
scroll: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
dataItemKey: {
type: PropType<string>;
};
defaultValue: {
type: PropType<any>;
default: any;
};
name: StringConstructor;
modelValue: {
type: PropType<any>;
default: any;
};
value: {
type: PropType<any>;
default: any;
};
label: {
type: PropType<string>;
};
placeholder: PropType<string>;
required: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
iconClassName: PropType<string>;
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: {
type: PropType<string>;
default: any;
};
tabIndex: {
type: PropType<number>;
default: number;
};
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
className: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: PropType<any>;
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
header: PropType<any>;
footer: PropType<any>;
filterable: PropType<boolean>;
filter: {
type: PropType<string>;
default: any;
};
virtual: {
type: PropType<VirtualizationSettings_2>;
default: any;
};
suggest: {
type: PropType<boolean>;
default: boolean;
};
allowCustom: {
type: PropType<boolean>;
default: boolean;
};
clearButton: {
type: PropType<boolean>;
default: boolean;
};
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
valueField: PropType<string>;
valuePrimitive: PropType<boolean>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
onFilterchange: PropType<(event: ComboBoxFilterChangeEvent_2) => void>;
inputAttributes: PropType<Object>;
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onScroll?: (...args: any[] | unknown[]) => any;
onOpen?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
onPagechange?: (...args: any[] | unknown[]) => any;
onFilterchange?: (...args: any[] | unknown[]) => any;
}>, {
filter: string;
required: boolean;
value: any;
ariaLabel: string;
tabIndex: number;
size: string;
rounded: string;
fillMode: string;
dir: string;
defaultValue: any;
opened: boolean;
popupSettings: DropDownsPopupSettings_2;
modelValue: any;
valid: boolean;
validationMessage: string;
validityStyles: boolean;
adaptive: boolean;
adaptiveTitle: string;
virtual: VirtualizationSettings_2;
clearButton: boolean;
suggest: boolean;
allowCustom: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the object of the `blur` ComboBox event.
 */
export declare interface ComboBoxBlurEvent extends BlurEvent {
}

/**
 * Represents the object of the `change` ComboBox event.
 */
export declare interface ComboBoxChangeEvent extends ChangeEvent {
}

/**
 * Represents the object of the `close` ComboBox event.
 */
export declare interface ComboBoxCloseEvent extends CloseEvent_2 {
}

/**
 * Represents the object of the `FilterChange` ComboBox event.
 */
export declare interface ComboBoxFilterChangeEvent extends FilterChangeEvent {
}

/**
 * Represents the object of the `focus` ComboBox event.
 */
export declare interface ComboBoxFocusEvent extends FocusEvent_2 {
}

/**
 * Represents the object of the `open` ComboBox event.
 */
export declare interface ComboBoxOpenEvent extends OpenEvent {
}

/**
 * Represents the object of the `PageChange` ComboBox event.
 */
export declare interface ComboBoxPageChangeEvent extends PageChangeEvent {
}

/**
 * Represents the props of the [Kendo UI for Vue ComboBox component]({% slug overview_combobox %}).
 */
export declare interface ComboBoxProps extends FormComponentProps {
    /**
     * Sets the dataItems of the ComboBox ([more information and examples]({% slug binding_combobox %})).
     */
    dataItems?: any[];
    /**
     * Sets the opened and closed state of the ComboBox.
     */
    opened?: boolean;
    /**
     * Sets the value of the ComboBox ([more information and examples]({% slug binding_combobox %})). It can either be of the primitive (string, numbers) or of the complex (objects) type.
     */
    value?: any;
    /**
     * Sets the default value of the ComboBox. Similar to the native `select` HTML element.
     */
    defaultValue?: any;
    /**
     * Defines the name for an existing arrow icon.
     */
    icon?: string;
    /**
     * Defines the svg icon in a Kendo UI for Vue theme.
     */
    svgIcon?: SVGIcon;
    /**
     * Sets CSS classes to the expand `icon` DOM element.
     */
    iconClassName?: string;
    /**
     * If `clearButton` is set to `true`, the ComboBox renders a button on hovering over the component. Clicking this button resets the value of the ComboBox to `undefined` and triggers the `change` event.
     */
    clearButton?: boolean;
    /**
     * The hint that is displayed when the ComboBox is empty.
     */
    placeholder?: string;
    /**
     * Enables the auto-completion of the text based on the first data item ([see example]({% slug suggestions_combobox %})).
     */
    suggest?: boolean;
    /**
     * Specifies whether the ComboBox allows user-defined values that are not present in the dataset ([see example]({% slug custom_values_combobox %})). Defaults to `false`.
     */
    allowCustom?: boolean;
    /**
     * Sets the disabled state of the ComboBox.
     */
    disabled?: boolean;
    /**
     * Sets additional classes to the DropDownList.
     */
    className?: string;
    /**
     * @hidden
     */
    modelValue?: any;
    /**
     * Represents the `dir` HTML attribute.
     */
    dir?: string;
    /**
     * Enables the filtering functionality of the ComboBox ([more information and examples]({% slug filtering_combobox %})).
     */
    filterable?: boolean;
    /**
     * Sets the value of ComboBox input. Useful for making the ComboBox input a controlled component.
     */
    filter?: string | null;
    /**
     * Sets the loading state of the ComboBox ([see example]({% slug filtering_combobox %}#toc-basic-configuration)).
     */
    loading?: boolean;
    /**
     * Specifies the `tabIndex` of the ComboBox.
     */
    tabIndex?: number;
    /**
     * Specifies the `accessKey` of the ComboBox.
     */
    accessKey?: string;
    /**
     * Sets the data item field that represents the item text. If the data contains only primitive values, do not define it.
     */
    textField?: string;
    /**
     * Sets the data item field that represents the item value.
     */
    valueField?: string;
    /**
     * Specifies the type of the selected value. If set to true, the selected value has to be of a primitive value.
     */
    valuePrimitive?: boolean;
    /**
     * Sets the key for comparing the data items of the ComboBox. If `dataItemKey` is not set, the ComboBox compares the items by reference ([see example]({% slug binding_combobox %}#toc-datasets-of-objects)).
     */
    dataItemKey?: string;
    /**
     * Renders a floating label for the ComboBox.
     */
    label?: string;
    /**
     * Configures the popup of the ComboBox.
     */
    popupSettings?: DropDownsPopupSettings;
    /**
     * Configures the virtual scrolling of the ComboBox ([more information and examples]({% slug virtualization_combobox %})).
     */
    virtual?: VirtualizationSettings;
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
     * For example these elements could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Defines the [aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label) attribute of the component.
     */
    ariaLabel?: string;
    /**
     * If set, the ComboBox will use it to get the focused item index.
     *
     * Default functionality returns the first item which starts with the input text.
     */
    focusedItemIndex?: (data: any, inputText: string, textField?: string) => number;
    /**
     * Fires each time the popup of the ComboBox is about to open.
     */
    onOpen?: (event: ComboBoxOpenEvent) => void;
    /**
     * Fires each time the popup of the ComboBox is about to close.
     */
    onClose?: (event: ComboBoxCloseEvent) => void;
    /**
     * Fires each time the user focuses the ComboBox.
     */
    onFocus?: (event: ComboBoxFocusEvent) => void;
    /**
     * Fires each time the ComboBox gets blurred.
     */
    onBlur?: (event: ComboBoxBlurEvent) => void;
    /**
     * Fires each time the value of the ComboBox is about to change ([see examples]({% slug binding_combobox %})).
     */
    onChange?: (event: ComboBoxChangeEvent) => void;
    /**
     * Fires each time the user types in the filter input ([see examples]({% slug filtering_combobox %}#toc-basic-configuration)). You can filter the source based on the passed filtration value.
     */
    onFilterchange?: (event: ComboBoxFilterChangeEvent) => void;
    /**
     * Fires when both the virtual scrolling of the ComboBox is enabled and the component requires data for another page ([more information and examples]({% slug virtualization_combobox %})).
     */
    onPagechange?: (event: ComboBoxPageChangeEvent) => void;
    /**
     * Fires when a ComboBox list item is about to be rendered ([see example]({% slug customrendering_combobox %}#toc-items)). Used to override the default appearance of the list items.
     */
    itemRender?: any;
    /**
     * Fires when the element which indicates no data in the popup is about to be rendered. Used to override the default appearance of the element.
     */
    listNoDataRender?: any;
    /**
     * Sets the header component of the ComboBox ([see example]({% slug customrendering_combobox %}#toc-headers-and-footers)).
     */
    header?: any;
    /**
     * Sets the footer component of the ComboBox ([see example]({% slug customrendering_combobox %}#toc-headers-and-footers)).
     */
    footer?: any;
    /**
     * Configures the `size` of the ComboBox.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - null&mdash;Does not set a size `class`.
     *
     * @default `medium`
     */
    size?: null | 'small' | 'medium' | 'large' | string;
    /**
     * Configures the `roundness` of the ComboBox.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - full
     * - null&mdash;Does not set a rounded `class`.
     *
     * @default `medium`
     */
    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `fillMode` of the ComboBox.
     *
     * The available options are:
     * - solid
     * - outline
     * - flat
     * - link
     * - null&mdash;Does not set a fillMode `class`.
     *
     * @default `solid`
     */
    fillMode?: null | 'solid' | 'outline' | 'flat' | string;
    /**
     * Sets the data item field that represents the start of a group. Applicable to objects data.
     */
    groupField?: string;
    /**
     * Fires when a ComboBox group header item is about to be rendered. Used to override the default appearance of the group's headers.
     */
    groupHeaderItemRender?: any;
    /**
     * Fires when a ComboBox sticky group header item is about to be rendered. Used to override the default appearance of the sticky group header of the component.
     */
    groupStickyHeaderItemRender?: any;
    /**
     * Provides different rendering of the popup element based on the screen dimensions ([see example]({% slug adaptive_rendering_combobox %})).
     */
    adaptive?: boolean;
    /**
     * Specifies the text that is rendered as title in the adaptive popup ([see example]({% slug adaptive_rendering_combobox %})).
     */
    adaptiveTitle?: string;
    /**
     * Sets the built-in HTML attributes of the inner focusable input element.
     * Attributes which are essential for certain component functionalities cannot be changed.
     */
    inputAttributes?: Object;
}

/**
 * @hidden
 */
declare interface DropdownEvent {
    /**
     * A native event.
     */
    event: any;
    /**
     * An event target.
     */
    target: any;
}

/**
 * @hidden
 */
export declare const DropDownList: DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
title: PropType<string>;
dataItemKey: {
type: PropType<string>;
};
defaultValue: {
type: PropType<any>;
default: any;
};
name: PropType<string>;
modelValue: {
type: PropType<any>;
default: any;
};
value: {
type: PropType<any>;
default: any;
};
label: {
type: PropType<string>;
};
required: {
type: PropType<boolean>;
default: boolean;
};
leftRightKeysNavigation: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
delay: {
type: PropType<number>;
default: number;
};
ignoreCase: {
type: PropType<boolean>;
default: boolean;
};
icon: PropType<string>;
svgIcon: PropType<SVGIcon>;
iconClassName: PropType<string>;
defaultItem: PropType<any>;
valueRender: PropType<any>;
valueMap: PropType<(value: any) => any>;
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: {
type: PropType<string>;
default: any;
};
tabIndex: {
type: PropType<number>;
default: number;
};
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
valueField: PropType<string>;
valuePrimitive: PropType<boolean>;
className: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: PropType<any>;
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
header: PropType<any>;
footer: PropType<any>;
filterable: PropType<boolean>;
filter: {
type: PropType<string>;
default: any;
};
virtual: {
type: PropType<VirtualizationSettings_2>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaLabel: PropType<string>;
ariaDescribedBy: PropType<string>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
onChange: PropType<(event: DropDownListChangeEvent_2) => void>;
}>, {
selectRef: Ref<any, any>;
baseWrapperRef: Ref<any, any>;
kendoAnchorRef: Ref<any, any>;
}, {
hasMounted: boolean;
currentText: string;
currentValue: string;
currentFocused: boolean;
currentOpened: boolean;
searchState: {
word: string;
last: string;
};
_skipFocusEvent: boolean;
valueDuringOnChange: {};
_navigated: boolean;
group: any;
isScrolling: boolean;
itemHeight: number;
state: any;
popupWidth: any;
windowWidth: number;
}, {
index(): number;
spanClassNames(): object;
dropDownListId(): string;
isOpen(): boolean;
animationStyles(): object | undefined;
classNameAdaptive(): string;
adaptiveState(): boolean;
}, {
focus(): void;
computedValue(): any;
findByFieldValue(field: string, value: string): any;
primitiveValue(): any;
validity(): FormComponentValidity;
handleItemSelect(index: number, state: InternalState): void;
onNavigate(state: InternalState, keyCode: number): void;
search(event: any): void;
selectNext(event: any): void;
handleKeyDown(event: any): void;
handleItemClick(index: number, event: any): void;
handleFocus(event: any): void;
handleBlur(event: any): void;
handleDefaultItemClick(event: any): void;
handleWrapperClick(event: MouseEvent): void;
handleKeyPress(event: any): void;
handleListFilterChange(event: any): void;
onPopupOpened(): void;
onPopupClosed(): void;
focusedIndex(): any;
focusElement(element: HTMLElement): void;
setValidity(): void;
triggerOnChange(item: any, state: InternalState): void;
applyState(state: InternalState): void;
calculateMedia(entries: ResizeObserverEntry[]): void;
repositionPopup(): void;
onScroll(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
title: PropType<string>;
dataItemKey: {
type: PropType<string>;
};
defaultValue: {
type: PropType<any>;
default: any;
};
name: PropType<string>;
modelValue: {
type: PropType<any>;
default: any;
};
value: {
type: PropType<any>;
default: any;
};
label: {
type: PropType<string>;
};
required: {
type: PropType<boolean>;
default: boolean;
};
leftRightKeysNavigation: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
delay: {
type: PropType<number>;
default: number;
};
ignoreCase: {
type: PropType<boolean>;
default: boolean;
};
icon: PropType<string>;
svgIcon: PropType<SVGIcon>;
iconClassName: PropType<string>;
defaultItem: PropType<any>;
valueRender: PropType<any>;
valueMap: PropType<(value: any) => any>;
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: {
type: PropType<string>;
default: any;
};
tabIndex: {
type: PropType<number>;
default: number;
};
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
valueField: PropType<string>;
valuePrimitive: PropType<boolean>;
className: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: PropType<any>;
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
header: PropType<any>;
footer: PropType<any>;
filterable: PropType<boolean>;
filter: {
type: PropType<string>;
default: any;
};
virtual: {
type: PropType<VirtualizationSettings_2>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaLabel: PropType<string>;
ariaDescribedBy: PropType<string>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
onChange: PropType<(event: DropDownListChangeEvent_2) => void>;
}>> & Readonly<{}>, {
filter: string;
required: boolean;
value: any;
tabIndex: number;
size: string;
rounded: string;
fillMode: string;
dir: string;
defaultValue: any;
opened: boolean;
popupSettings: DropDownsPopupSettings_2;
modelValue: any;
valid: boolean;
validationMessage: string;
validityStyles: boolean;
adaptive: boolean;
adaptiveTitle: string;
virtual: VirtualizationSettings_2;
delay: number;
ignoreCase: boolean;
leftRightKeysNavigation: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the object of the `blur` DropDownList event.
 */
export declare interface DropDownListBlurEvent extends BlurEvent {
}

/**
 * Represents the object of the `change` DropDownList event.
 */
export declare interface DropDownListChangeEvent extends ChangeEvent {
}

/**
 * Represents the object of the `close` DropDownList event.
 */
export declare interface DropDownListCloseEvent extends CloseEvent_2 {
}

/**
 * Represents the object of the `filterChange` DropDownList event.
 */
export declare interface DropDownListFilterChangeEvent extends FilterChangeEvent {
}

/**
 * Represents the object of the `focus` DropDownList event.
 */
export declare interface DropDownListFocusEvent extends FocusEvent_2 {
}

/**
 * Represents the object of the `open` DropDownList event.
 */
export declare interface DropDownListOpenEvent extends OpenEvent {
}

/**
 * Represents the object of the `pageChange` DropDownList event.
 */
export declare interface DropDownListPageChangeEvent extends PageChangeEvent {
}

/**
 * Represents the props of the [KendoVue DropDownList component]({% slug overview_dropdownlist %}).
 */
export declare interface DropDownListProps extends FormComponentProps {
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Specifies the title of the component.
     */
    title?: string;
    /**
     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
     * For example these elements could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Defines the [aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label) attribute of the component.
     */
    ariaLabel?: string;
    /**
     * There is no placeholder concept when it comes to DropDownList/HTML select element. The approach
     * that we recommend in such cases is to use the default Item as it is shown here ([see example]({% slug defaultitem_dropdownlist %})).
     */
    placeholder?: string;
    /**
     * Sets the validate of the input.
     */
    validate?: boolean;
    /**
     * Sets the data of the DropDownList ([see example]({% slug binding_dropdownlist %})).
     */
    dataItems?: any[];
    /**
     * Sets the text of the default empty item. The type of the defined value has to match the data type.
     */
    defaultItem?: any;
    /**
     * Sets the delay before an item search is performed. When filtration is disabled, use this option.
     */
    delay?: number;
    /**
     * Enables a case-insensitive search. When filtering is disabled, use this option.
     */
    ignoreCase?: boolean;
    /**
     * Sets the opened and closed state of the DropDownList.
     */
    opened?: boolean;
    /**
     * The styles that are applied to the DropDownList.
     */
    style?: any;
    /**
     * @hidden
     */
    modelValue?: any;
    /**
     * Sets the value of the DropDownList ([see example]({% slug binding_dropdownlist %})). It can either be of the primitive (string, numbers) or of the complex (objects) type.
     */
    value?: any;
    /**
     * Sets the default value of the DropDownList ([see example]({% slug defaultitem_dropdownlist %})). Similar to the native `select` HTML element.
     */
    defaultValue?: any;
    /**
     * Sets additional classes to the DropDownList.
     */
    className?: string;
    /**
     * Defines the name for an existing arrow icon.
     */
    icon?: string;
    /**
     * Defines the svg icon in a Kendo UI for Vue theme.
     */
    svgIcon?: SVGIcon;
    /**
     * Sets CSS classes to the expand `icon` DOM element.
     */
    iconClassName?: string;
    /**
     * Sets the disabled state of the DropDownList.
     */
    disabled?: boolean;
    /**
     * Represents the `dir` HTML attribute.
     */
    dir?: string;
    /**
     * Enables the filtering functionality of the DropDownList ([more information and examples]({% slug filtering_dropdownlist %})).
     */
    filterable?: boolean;
    /**
     * Sets the value of filtering input.
     */
    filter?: string;
    /**
     * Sets the loading state of the DropDownList.
     */
    loading?: boolean;
    /**
     * Specifies the `tabIndex` of the DropDownList.
     */
    tabIndex?: number;
    /**
     * Specifies the `accessKey` of the DropDownList.
     */
    accessKey?: string;
    /**
     * Sets the data item field that represents the item text ([see example]({% slug defaultitem_dropdownlist %})). If the data contains only primitive values, do not define it.
     */
    textField?: string;
    /**
     * Sets the data item field that represents the item value.
     */
    valueField?: string;
    /**
     * Specifies the type of the selected value. If set to true, the selected value has to be of a primitive value.
     */
    valuePrimitive?: boolean;
    /**
     * Sets the key for comparing the data items of the DropDownList. If `dataItemKey` is not set, the DropDownList compares the items by reference ([see example]({% slug binding_dropdownlist %}#toc-datasets-of-objects)).
     */
    dataItemKey?: string;
    /**
     * Represents a callback function, which returns the value for submitting. The returned value will be rendered in an `option` of a hidden `select` element.
     */
    valueMap?: (value: any) => any;
    /**
     * Renders a floating label for the DropDownList.
     */
    label?: string;
    /**
     * Configures the popup of the DropDownList.
     */
    popupSettings?: DropDownsPopupSettings;
    /**
     * Configures the virtual scrolling of the DropDownList ([see example]({% slug virtualization_dropdownlist %})).
     */
    virtual?: VirtualizationSettings;
    /**
     * If set, the DropDownList will use it to get the focused item index.
     *
     * Default functionality returns the first item which starts with the input text.
     *
     */
    focusedItemIndex?: (data: any, inputText: string, textField?: string) => number;
    /**
     * Fires each time the popup of the DropDownList is about to open.
     */
    onOpen?: (event: DropDownListOpenEvent) => void;
    /**
     * Fires each time the popup of the DropDownList is about to close.
     */
    onClose?: (event: DropDownListCloseEvent) => void;
    /**
     * Fires each time the user focuses the DropDownList.
     */
    onFocus?: (event: DropDownListFocusEvent) => void;
    /**
     * Fires each time the DropDownList gets blurred.
     */
    onBlur?: (event: DropDownListBlurEvent) => void;
    /**
     * Fires each time the value of the DropDownList is about to change ([see examples]({% slug binding_dropdownlist %})).
     */
    onChange?: (event: DropDownListChangeEvent) => void;
    /**
     * Fires each time the user types in the filter input. You can filter the source based on the passed filtration value.
     */
    onFilterchange?: (event: DropDownListFilterChangeEvent) => void;
    /**
     * Fires when both the virtual scrolling of the DropDownList is enabled and the component requires data for another page ([see example]({% slug virtualization_dropdownlist %})).
     */
    onPagechange?: (event: DropDownListPageChangeEvent) => void;
    /**
     * Fires when a DropDownList item is about to be rendered ([see example]({% slug customrendering_dropdownlist %}#toc-items)). Used to override the default appearance of the list items.
     */
    itemRender?: any;
    /**
     * Fires when the element which renders the value is about to be rendered ([see example]({% slug customrendering_dropdownlist %}#toc-values)). Used to override the default appearance of the element.
     */
    valueRender?: any;
    /**
     * Fires when the element which indicates no data in the popup is about to be rendered ([see example]({% slug customrendering_dropdownlist %}#toc-no-data)). Used to override the default appearance of the element.
     */
    listNoDataRender?: any;
    /**
     * Sets the header component of the DropDownList ([see example]({% slug customrendering_dropdownlist %}#toc-headers-and-footers)).
     */
    header?: any;
    /**
     * Sets the footer component of the DropDownList ([see example]({% slug customrendering_dropdownlist %}#toc-headers-and-footers)).
     */
    footer?: any;
    /**
     * Specifies the `name` property of the `select` DOM element.
     */
    name?: string;
    /**
     * If set to `false`, the DropDownList will not navigate over its data through left and right keys.
     * Useful when the DropDownList is placed inside a toolbar which needs to handle left and right keys.
     */
    leftRightKeysNavigation?: boolean;
    /**
     * Configures the `size` of the DropDownList.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - null&mdash;Does not set a size `class`.
     *
     * @default `medium`
     */
    size?: null | 'small' | 'medium' | 'large' | string;
    /**
     * Configures the `roundness` of the DropDownList.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - full
     * - null&mdash;Does not set a rounded `class`.
     *
     * @default `medium`
     */
    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `fillMode` of the DropDownList.
     *
     * The available options are:
     * - solid
     * - outline
     * - flat
     * - null&mdash;Does not set a fillMode `class`.
     *
     * @default `solid`
     */
    fillMode?: null | 'solid' | 'outline' | 'flat' | string;
    /**
     * Sets the data item field that represents the start of a group. Applicable to objects data.
     */
    groupField?: string;
    /**
     * Fires when a DropDownList group header item is about to be rendered. Used to override the default appearance of the group's headers.
     */
    groupHeaderItemRender?: any;
    /**
     * Fires when a DropDownList sticky group header item is about to be rendered. Used to override the default appearance of the sticky group header of the component.
     */
    groupStickyHeaderItemRender?: any;
    /**
     * Provides different rendering of the popup element based on the screen dimensions ([see example]({% slug adaptive_rendering_dropdownlist %})).
     */
    adaptive?: boolean;
    /**
     * Specifies the text that is rendered as title in the adaptive popup ([see example]({% slug adaptive_rendering_dropdownlist %})).
     */
    adaptiveTitle?: string;
}

/**
 * The settings of the popup container.
 */
export declare interface DropDownsPopupSettings extends PopupSettings {
    /**
     * Controls the popup animation. By default, the open and close animations are enabled.
     */
    animate?: boolean | PopupAnimation;
    /**
     * Specifies a list of CSS classes that will be added to the Popup element.
     */
    className?: string | Array<string>;
    /**
     * Sets the width of the popup container. By default, the width of the host element is used.
     */
    width?: string;
    /**
     * Sets the height of the popup container. By default, the height is 200px.
     */
    height?: string;
    /**
     * Sets the styles that will be added to the popup element.
     */
    popupStyle?: string;
}

/**
 * @hidden
 */
declare interface DropDownStateBase {
    /**
     * Input element text of the Component.
     */
    text?: string;
    value?: any;
    focused?: boolean;
    opened?: boolean;
    group?: string;
    currentText?: string;
    currentFocused?: boolean;
    currentOpened?: boolean;
    focusedItem?: any;
}

/**
 * @hidden
 */
export declare const DropDownTree: DefineComponent<ExtractPropTypes<    {
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: PropType<string>;
tabIndex: PropType<number>;
accessKey: PropType<string>;
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
value: {
type: PropType<any>;
default: () => any;
};
modelValue: {
type: PropType<any>;
default: () => any;
};
valueMap: PropType<(value: any) => any>;
placeholder: PropType<string>;
dataItemKey: {
type: PropType<string>;
required: true;
};
textField: {
type: PropType<string>;
required: true;
};
selectField: {
type: PropType<string>;
default: string;
};
expandField: PropType<string>;
subItemsField: {
type: PropType<string>;
default: string;
};
className: PropType<string>;
label: PropType<string>;
validationMessage: PropType<string>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
required: PropType<boolean>;
name: PropType<string>;
id: PropType<string>;
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
filterable: PropType<boolean>;
filter: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_3>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
item: PropType<any>;
header: PropType<any>;
footer: PropType<any>;
valueRender: PropType<any>;
listNoData: PropType<any>;
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
}>, {}, {
currentOpened: boolean;
focused: boolean;
filterState: string;
currentValue: any;
popupWidth: string;
windowWidth: number;
initialAdaptiveRenderingValues: any;
}, {
wrapperClass(): {
[x: string]: any;
[x: number]: any;
'k-dropdowntree': boolean;
'k-picker': boolean;
'k-focus': any;
'k-invalid': boolean;
'k-loading': any;
'k-required': any;
'k-disabled': any;
};
animationStyles(): object | undefined;
classNameAdaptive(): string;
adaptiveState(): any;
isOpen(): any;
computedValue(): any;
hasValue(): boolean;
currentValueText(): any;
}, {
calculateMedia(entries: ResizeObserverEntry[]): void;
calculatePopupWidth(): void;
focus(): void;
setValidity(): void;
openPopup(event: DropdownEvent): void;
closePopup(event: DropdownEvent): void;
onWrapperClick(event: any): void;
switchFocus(focusFn: () => void): void;
onWrapperKeyDown(event: any): any;
onInputKeyDown(event: KeyboardEvent): void;
focusElement(element: HTMLElement | null): void;
onPopupOpened(): void;
onPopupClosed(): void;
onFocus(event: any): void;
onBlur(event: any): void;
onWrapperMouseDown(): void;
changeValue(event: DropdownEvent, newValue: any, hierarchicalIndex?: string): void;
onChange(e: TreeViewItemClickEvent): void;
onClear(event: any): void;
onExpand(e: TreeViewExpandChangeEvent): void;
onFilterChange(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
open: any;
close: any;
focus: any;
blur: any;
change: any;
filterchange: any;
expandchange: any;
changemodel: any;
'update:modelValue': any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: PropType<string>;
tabIndex: PropType<number>;
accessKey: PropType<string>;
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
value: {
type: PropType<any>;
default: () => any;
};
modelValue: {
type: PropType<any>;
default: () => any;
};
valueMap: PropType<(value: any) => any>;
placeholder: PropType<string>;
dataItemKey: {
type: PropType<string>;
required: true;
};
textField: {
type: PropType<string>;
required: true;
};
selectField: {
type: PropType<string>;
default: string;
};
expandField: PropType<string>;
subItemsField: {
type: PropType<string>;
default: string;
};
className: PropType<string>;
label: PropType<string>;
validationMessage: PropType<string>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
required: PropType<boolean>;
name: PropType<string>;
id: PropType<string>;
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
filterable: PropType<boolean>;
filter: PropType<string>;
loading: PropType<boolean>;
popupSettings: {
type: PropType<DropDownsPopupSettings_3>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
item: PropType<any>;
header: PropType<any>;
footer: PropType<any>;
valueRender: PropType<any>;
listNoData: PropType<any>;
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onOpen?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
onFilterchange?: (...args: any[] | unknown[]) => any;
onExpandchange?: (...args: any[] | unknown[]) => any;
}>, {
value: any;
ariaLabel: string;
size: string;
rounded: string;
fillMode: string;
dataItems: any[];
opened: boolean;
popupSettings: DropDownsPopupSettings_3;
modelValue: any;
valid: boolean;
validityStyles: boolean;
adaptive: boolean;
adaptiveTitle: string;
selectField: string;
subItemsField: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the object of the `onBlur` DropDownTree event.
 */
export declare interface DropDownTreeBlurEvent extends BlurEvent {
}

/**
 * Represents the object of the `onChange` DropDownTree event.
 */
export declare interface DropDownTreeChangeEvent extends ChangeEvent {
    level: number[];
}

/**
 * Represents the object of the `onClose` DropDownTree event.
 */
export declare interface DropDownTreeCloseEvent extends CloseEvent_2 {
}

/**
 * Represents the object of the `onExpandChange` DropDownTree event.
 */
export declare interface DropDownTreeExpandEvent extends DropdownEvent {
    item: any;
    level: number[];
}

/**
 * Represents the object of the `onFilterChange` DropDownTree event.
 */
export declare interface DropDownTreeFilterChangeEvent extends FilterChangeEvent {
}

/**
 * Represents the object of the `onFocus` DropDownTree event.
 */
export declare interface DropDownTreeFocusEvent extends FocusEvent_2 {
}

/**
 * Represents the Object which is passed to the
 */
export declare interface DropDownTreeHandle {
    /**
     * The current element or `null` if there is no one.
     */
    element: HTMLElement | null;
    /**
     * The props of the DropDownTree component.
     */
    props: DropDownTreeProps;
    /**
     * The focus function.
     */
    focus: () => void;
}

/**
 * Represents the object of the `onOpen` DropDownTree event.
 */
export declare interface DropDownTreeOpenEvent extends OpenEvent {
}

/**
 * Represents the props of the [Kendo UI for Vue DropDownTree component]({% slug overview_dropdowntree %}).
 */
export declare interface DropDownTreeProps extends FormComponentProps {
    /**
     * Sets the data of the DropDownTree ([see example]({% slug overview_dropdowntree %})).
     */
    dataItems?: any[];
    /**
     * Sets the opened state of the DropDownTree.
     */
    opened?: boolean;
    /**
     * Sets the value of the DropDownTree ([see example]({% slug overview_dropdowntree %})).
     * It can be an object from the data-tree.
     */
    value?: any;
    modelValue?: any;
    /**
     * The hint that is displayed when the DropDownTree is empty.
     */
    placeholder?: string;
    /**
     * Sets the key for comparing the data items of the DropDownTree ([see example]({% slug overview_dropdowntree %})).
     * If `dataItemKey` is not set, the DropDownTree compares the items by reference.
     */
    dataItemKey: string;
    /**
     * Sets additional classes to the DropDownTree.
     */
    className?: string;
    /**
     * Sets the disabled state of the DropDownTree.
     */
    disabled?: boolean;
    /**
     * Represents the `dir` HTML attribute.
     */
    dir?: string;
    /**
     * Renders a floating label for the DropDownTree.
     */
    label?: string;
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
     * For example these elements could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Defines the [aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label) attribute of the component.
     */
    ariaLabel?: string;
    /**
     * Enables the filtering functionality of the DropDownTree ([more information and examples]({% slug filtering_dropdowntree %})).
     */
    filterable?: boolean;
    /**
     * Sets the value of filtering input.
     * Useful for making the filtering input a controlled component.
     */
    filter?: string;
    /**
     * Sets the loading state of the DropDownTree ([see example]({% slug filtering_dropdowntree %}#toc-visualize-filtering)).
     */
    loading?: boolean;
    /**
     * Specifies the `tabIndex` of the DropDownTree.
     */
    tabIndex?: number;
    /**
     * Specifies the `accessKey` of the DropDownTree.
     */
    accessKey?: string;
    /**
     * Sets the data item field that represents the item text ([see example]({% slug overview_dropdowntree %})).
     */
    textField: string;
    /**
     * Specifies the name of the field which will provide a Boolean representation of the selected state of the item.
     */
    selectField?: string;
    /**
     * Specifies the name of the field which will provide a Boolean representation of the expanded state of the item.
     */
    expandField?: string;
    /**
     * Specifies the name of the field which will provide an array representation of the item subitems.
     * Defaults to 'items'.
     */
    subItemsField?: string;
    /**
     * Configures the popup of the DropDownTree.
     */
    popupSettings?: DropDownsPopupSettings;
    /**
     * Represents a callback function, which returns the value for submitting. The returned value will be rendered in an `option` of a hidden `select`.
     *
     * @example
     * ```jsx-no-run
     * class App extends React.Component {
     *    render() {
     *       return (
     *          <form>
     *              <DropDownTree
     *                  data={[ { text: "Austria", id: 1 } , { text: "Belarus", id: 2 } ]}
     *                  valueMap={value => value && value.id}
     *              />
     *              <button type="submit">Submit</button>
     *          </form>
     *       );
     *    }
     * }
     * ReactDOM.render(<App />, document.querySelector('my-app'));
     * ```
     */
    valueMap?: (value: any) => any;
    /**
     * Fires each time the popup of the DropDownTree is about to open.
     */
    onOpen?: (event: DropDownTreeOpenEvent) => void;
    /**
     * Fires each time the popup of the DropDownTree is about to close.
     */
    onClose?: (event: DropDownTreeCloseEvent) => void;
    /**
     * Fires each time the user focuses the DropDownTree.
     */
    onFocus?: (event: DropDownTreeFocusEvent) => void;
    /**
     * Fires each time the DropDownTree gets blurred.
     */
    onBlur?: (event: DropDownTreeBlurEvent) => void;
    /**
     * Fires each time the value of the DropDownTree is about to change ([see examples]({% slug overview_dropdowntree %})).
     */
    onChange?: (event: DropDownTreeChangeEvent) => void;
    /**
     * Fires each time the user types in the filter input
     * ([see example]({% slug filtering_dropdowntree %}#toc-basic-configuration)).
     * You can filter the source based on the passed filtration value.
     */
    onFilterChange?: (event: DropDownTreeFilterChangeEvent) => void;
    /**
     * Fires when the expanding or collapsing of an item is requested ([see examples]({% slug overview_dropdowntree %})).
     */
    onExpandChange?: (event: any) => void;
    /**
     * Defines the slot that will be used for rendering each of the DropDownTree items
     * ([see example]({% slug customrendering_dropdowntree %}#toc-items-and-value-element)).
     */
    item?: any;
    /**
     * Defines the slot that will be used for rendering the selected value
     * ([see example]({% slug customrendering_dropdowntree %}#toc-items-and-value-element)).
     */
    valueRender?: any;
    /**
     * Defines the slot that will be used for header
     * ([see example]({% slug customrendering_dropdowntree %}#toc-items-and-value-element)).
     */
    header?: any;
    /**
     * Defines the slot that will be used for footer
     * ([see example]({% slug customrendering_dropdowntree %}#toc-items-and-value-element)).
     */
    footer?: any;
    /**
     * Defines the slot that will be rendered in the DropDownTree popup when no data is available
     * ([see example]({% slug customrendering_dropdowntree %}#toc-no-data)).
     */
    listNoData?: any;
    /**
     * Configures the `size` of the DropDownTree.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - null&mdash;Does not set a size `className`.
     *
     * @default `medium`
     */
    size?: null | 'small' | 'medium' | 'large' | string;
    /**
     * Configures the `roundness` of the DropDownTree.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - full
     * - null&mdash;Does not set a rounded `className`.
     *
     * @default `medium`
     */
    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `fillMode` of the DropDownTree.
     *
     * The available options are:
     * - solid
     * - flat
     * - outline
     * - null&mdash;Does not set a fillMode `className`.
     *
     * @default `solid`
     */
    fillMode?: null | 'solid' | 'flat' | 'outline' | string;
    /**
     * Provides different rendering of the popup element based on the screen dimensions.
     */
    adaptive?: boolean;
    /**
     * Specifies the text that is rendered as title in the adaptive popup.
     */
    adaptiveTitle?: string;
}

/**
 * @hidden
 */
declare interface EventData {
    type?: string;
    filter?: FilterDescriptor;
    page?: Page;
    suggestion?: Suggestion;
}

/**
 * @hidden
 */
declare interface FilterChangeEvent extends DropdownEvent {
    /**
     * A native event.
     */
    event: any;
    /**
     * The default `FilterDescriptor` object.
     */
    filter: FilterDescriptor;
}

/**
 * A basic filter expression. Usually a part of [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}).
 *
 * For more information, refer to the [`filterBy`]({% slug api_kendo-data-query_filterby %}) method.
 */
declare interface FilterDescriptor {
    /**
     * The field of the data item to which the filter operator is applied.
     */
    field?: string | Function;
    /**
     * The filter operator (comparison).
     *
     * The supported operators are:
     * * `"eq"` (equal to)
     * * `"neq"` (not equal to)
     * * `"isnull"` (is equal to null)
     * * `"isnotnull"` (is not equal to null)
     * * `"lt"` (less than)
     * * `"lte"` (less than or equal to)
     * * `"gt"` (greater than)
     * * `"gte"` (greater than or equal to)
     *
     * The following operators are supported for string fields only:
     * * `"startswith"`
     * * `"endswith"`
     * * `"contains"`
     * * `"doesnotcontain"`
     * * `"isempty"`
     * * `"isnotempty"`
     */
    operator: string | Function;
    /**
     * The value to which the field is compared. Has to be of the same type as the field.
     */
    value?: any;
    /**
     * Determines if the string comparison is case-insensitive.
     */
    ignoreCase?: boolean;
}

declare enum FocusedItemType {
    None = 0,
    ListItem = 1,
    CustomItem = 2
}

/**
 * @hidden
 */
declare interface FocusEvent_2 extends DropdownEvent {
}

export { FormComponentValidity }

/**
 * Get MultiSelectTree new value from the component `onChange` event.
 *
 * @param {any[]} data
 * @param {object} options
 * @returns {any[]}
 */
export declare const getMultiSelectTreeValue: (data: any[], options: {
    subItemsField?: string;
    dataItemKey: string;
    items: any;
    value: Array<any>;
    operation: MultiSelectTreeChangeEventOperation;
}) => any[];

/** @hidden */
export declare const getValueMap: (value: any[], idGetter: any) => any;

/**
 * @hidden
 */
declare interface InternalState {
    data: DropDownStateBase;
    events: Array<EventData>;
    event: any;
}

/**
 * The props of component that will be used for rendering each of the DropDownTree items
 * ([see example]({% slug customrendering_dropdowntree %}#toc-items-and-value-element)).
 */
export declare interface ItemProps extends ItemRenderProps {
}

declare interface ListFocusedState {
    focusedItem?: any;
    focusedIndex: number;
    focusedType: FocusedItemType;
}

/**
 * Represents the props of the ListItem component.
 */
export declare interface ListItemProps {
    /**
     * Specifies the id that will be added to the list item element.
     */
    id?: string;
    /**
     * Represents the index of the list item element.
     */
    index: number;
    /**
     * Represents the data item of the list item element.
     */
    dataItem: any;
    /**
     * Sets the data item field that represents the item text. If the data contains only primitive values, do not define it.
     */
    textField?: string;
    /**
     * Indicates the focused state of the list item element.
     */
    focused: boolean;
    /**
     * Indicates the selected state of the list item element.
     */
    selected: boolean;
    /**
     * Fires when the list item is about to be rendered. Used to override the default appearance of the list item.
     */
    render?: any;
    /**
     * The `onClick` event handler of the list item element.
     */
    onItemClick?: (index: number, event: any) => void;
}

/**
 * The props of the `ListNoData` component ([see example]({% slug customrendering_dropdowntree %}#toc-no-data)).
 */
export declare interface ListNoDataProps {
}

/**
 * @hidden
 */
export declare const MultiSelect: DefineComponent<ExtractPropTypes<    {
autoClose: {
type: PropType<boolean>;
default: boolean;
};
removeTagIcon: PropType<string>;
allowCustom: PropType<boolean>;
modelValue: PropType<any>;
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: PropType<string>;
tabIndex: {
type: PropType<number>;
default: number;
};
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
label: PropType<string>;
loading: PropType<boolean>;
name: PropType<string>;
value: PropType<any[]>;
defaultValue: PropType<any[]>;
valueField: PropType<string>;
valuePrimitive: PropType<boolean>;
dataItemKey: PropType<string>;
placeholder: PropType<string>;
tags: PropType<MultiSelectTagData[]>;
required: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
tagRender: PropType<any>;
id: PropType<string>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: PropType<any>;
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
virtual: {
type: PropType<VirtualizationSettings_2>;
default: any;
};
header: PropType<any>;
footer: PropType<any>;
filterable: PropType<boolean>;
filter: {
type: PropType<string>;
default: any;
};
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
tagsRounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
inputAttributes: PropType<Object>;
}>, {
inputRef: Ref<any, any>;
kendoAnchorRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
hasMounted: boolean;
currentText: string;
currentValue: string;
currentFocused: boolean;
currentOpened: boolean;
currentFocusedIndex: any;
currentFocusedTag: any;
searchState: {
word: string;
last: string;
};
suggested: string;
activedescendant: ActiveDescendant;
group: any;
isScrolling: boolean;
itemHeight: number;
windowWidth: number;
popupWidth: any;
initialAdaptiveRenderingValues: any;
}, {
spanClassNames(): object;
isOpen(): boolean;
animationStyles(): object | undefined;
classNameAdaptive(): string;
adaptiveState(): any;
}, {
clearFilter(state: MultiSelectInternalState): void;
computedValue(): any;
findByFieldValue(field: string, result: Array<any>): any[];
primitiveValue(): any;
validity(): FormComponentValidity;
handleItemSelect(index: number, state: MultiSelectInternalState): void;
onTagDelete(itemsToRemove: Array<any>, event: any): void;
onNavigate(state: MultiSelectInternalState, keyCode: number): void;
itemFocus(index: number, state: MultiSelectInternalState): void;
searchBarRef(): void;
onChangeHandler(event: any): void;
clearButtonClick(event: any): void;
onInputKeyDown(event: any): any;
onTagsNavigate(event: any, state: MultiSelectInternalState): void;
triggerOnChange(items: Array<any>, state: MultiSelectInternalState): void;
selectFocusedItem(event: any): void;
setItems(srcItems: Array<any>, destItems: Array<any>): void;
getFocusedState(): ListFocusedState;
customItemSelect(event: any): void;
handleWrapperClick(event: MouseEvent): void;
onCancel(event: MouseEvent): void;
handleItemClick(index: number, event: any): void;
handleBlur(event: any): void;
handleFocus(event: any): void;
onPopupOpened(): void;
onPopupClosed(): void;
focusElement(element: any): void;
applyState(state: MultiSelectInternalState): void;
setValidity(): void;
focus(): void;
calculateMedia(entries: ResizeObserverEntry[]): void;
repositionPopup(): void;
onScroll(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
changemodel: any;
'update:modelValue': any;
filterchange: any;
change: any;
pagechange: any;
focus: any;
blur: any;
open: any;
close: any;
scroll: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
autoClose: {
type: PropType<boolean>;
default: boolean;
};
removeTagIcon: PropType<string>;
allowCustom: PropType<boolean>;
modelValue: PropType<any>;
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: PropType<string>;
tabIndex: {
type: PropType<number>;
default: number;
};
accessKey: PropType<string>;
dataItems: PropType<any[]>;
textField: PropType<string>;
label: PropType<string>;
loading: PropType<boolean>;
name: PropType<string>;
value: PropType<any[]>;
defaultValue: PropType<any[]>;
valueField: PropType<string>;
valuePrimitive: PropType<boolean>;
dataItemKey: PropType<string>;
placeholder: PropType<string>;
tags: PropType<MultiSelectTagData[]>;
required: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
validate: {
type: PropType<boolean>;
};
validationMessage: {
type: PropType<string>;
default: any;
};
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
tagRender: PropType<any>;
id: PropType<string>;
popupSettings: {
type: PropType<DropDownsPopupSettings_2>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
itemRender: PropType<any>;
groupHeaderItemRender: PropType<any>;
groupStickyHeaderItemRender: PropType<any>;
listNoDataRender: PropType<any>;
focusedItemIndex: PropType<(data: any, inputText: string, textField?: string) => number>;
virtual: {
type: PropType<VirtualizationSettings_2>;
default: any;
};
header: PropType<any>;
footer: PropType<any>;
filterable: PropType<boolean>;
filter: {
type: PropType<string>;
default: any;
};
ariaLabel: {
type: PropType<string>;
default: any;
};
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
rounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
tagsRounded: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
size: {
type: PropType<string>;
default: string;
validator: (value: string) => any;
};
groupField: {
type: PropType<string>;
};
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
inputAttributes: PropType<Object>;
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onScroll?: (...args: any[] | unknown[]) => any;
onOpen?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
onPagechange?: (...args: any[] | unknown[]) => any;
onFilterchange?: (...args: any[] | unknown[]) => any;
}>, {
filter: string;
required: boolean;
ariaLabel: string;
tabIndex: number;
size: string;
rounded: string;
fillMode: string;
opened: boolean;
popupSettings: DropDownsPopupSettings_2;
valid: boolean;
validationMessage: string;
validityStyles: boolean;
adaptive: boolean;
adaptiveTitle: string;
tagsRounded: string;
virtual: VirtualizationSettings_2;
autoClose: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the object of the `blur` MultiSelect event.
 */
export declare interface MultiSelectBlurEvent extends BlurEvent {
}

/**
 * Represents the object of the `change` MultiSelect event.
 */
export declare interface MultiSelectChangeEvent extends ChangeEvent {
}

/**
 * Represents the object of the `close` MultiSelect event.
 */
export declare interface MultiSelectCloseEvent extends CloseEvent_2 {
}

/**
 * @hidden
 */
declare interface MultiSelectData extends DropDownStateBase {
    hasMounted: boolean;
    selectedItems?: Array<any>;
    valuesItemsDuringOnChange?: Array<any> | null;
    currentText?: string;
    currentFocusedIndex?: number;
    currentFocused?: boolean;
    currentOpened?: boolean;
    currentFocusedTag?: any;
    currentValue?: Array<any>;
    activedescendant?: ActiveDescendant;
    _skipFocusEvent: boolean;
}

/**
 * Represents the object of the `filterChange` MultiSelect event.
 */
export declare interface MultiSelectFilterChangeEvent extends FilterChangeEvent {
}

/**
 * Represents the object of the `focus` MultiSelect event.
 */
export declare interface MultiSelectFocusEvent extends FocusEvent_2 {
}

/**
 * @hidden
 */
declare interface MultiSelectInternalState extends InternalState {
    data: MultiSelectData;
}

/**
 * Represents the object of the `open` MultiSelect event.
 */
export declare interface MultiSelectOpenEvent extends OpenEvent {
}

/**
 * Represents the object of the `pageChange` MultiSelect event.
 */
export declare interface MultiSelectPageChangeEvent extends PageChangeEvent {
}

/**
 * Represents the props of the [Kendo UI for Vue MultiSelect component]({% slug overview_multiselect %}).
 */
export declare interface MultiSelectProps extends FormComponentProps {
    /**
     * Specifies whether the MultiSelect allows user-defined values that are not present in the dataset ([see example]({% slug custom_values_multiselect %})). Defaults to `false`.
     */
    allowCustom?: boolean;
    /**
     * Sets the data of the MultiSelect ([see example]({% slug binding_multiselect %})).
     */
    dataItems?: any[];
    /**
     * Sets the opened and closed state of the MultiSelect.
     */
    opened?: boolean;
    /**
     * Determines whether to close the options list of the MultiSelect after the item selection is finished.
     *
     * @default true
     */
    autoClose?: boolean;
    /**
     * @hidden
     */
    modelValue?: any;
    /**
     * Sets the value of the MultiSelect ([see example]({% slug binding_multiselect %})). It can either be of the primitive (string, numbers) or of the complex (objects) type.
     */
    value?: Array<any>;
    /**
     * Sets the validate of the input.
     */
    validate?: boolean;
    /**
     * The hint that is displayed when the MultiSelect is empty.
     */
    placeholder?: string;
    /**
     * Sets the close icon of the tag items.
     */
    removeTagIcon?: string;
    /**
     * Sets the tags of the MultiSelect ([see example]({% slug customtags_multiselect %})).
     */
    tags?: Array<MultiSelectTagData>;
    /**
     * Sets the data item field that represents the item value.
     */
    valueField?: string;
    /**
     * Specifies the type of the selected value. If set to true, the selected value has to be of a primitive value.
     */
    valuePrimitive?: boolean;
    /**
     * Sets the key for comparing the data items of the MultiSelect ([see example]({% slug binding_multiselect %}#toc-datasets-of-objects)). If `dataItemKey` is not set, the MultiSelect compares the items by reference.
     */
    dataItemKey?: string;
    /**
     * Sets the default value of the MultiSelect. Similar to the native `select` HTML element.
     */
    defaultValue?: Array<any>;
    /**
     * Sets the disabled state of the MultiSelect.
     */
    disabled?: boolean;
    /**
     * Represents the `dir` HTML attribute.
     */
    dir?: string;
    /**
     * Enables the filtering functionality of the MultiSelect ([more information and examples]({% slug filtering_multiselect %})).
     */
    filterable?: boolean;
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
     * For example these elements could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Defines the [aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label) attribute of the component.
     */
    ariaLabel?: string;
    /**
     * If set, the MultiSelect will use it to get the focused item index.
     *
     * Default functionality returns the first item which starts with the input text.
     *
     */
    focusedItemIndex?: (data: any, inputText: string, textField?: string) => number;
    /**
     * Sets the value of filtering input. Useful for making the filtering input a controlled component.
     */
    filter?: string;
    /**
     * Sets the loading state of the MultiSelect ([see example]({% slug filtering_multiselect %}#toc-basic-configuration)).
     */
    loading?: boolean;
    /**
     * Specifies the `tabIndex` of the MultiSelect.
     */
    tabIndex?: number;
    /**
     * Specifies the `accessKey` of the MultiSelect.
     */
    accessKey?: string;
    /**
     * Sets the data item field that represents the item text ([see example]({% slug binding_multiselect %}#toc-datasets-of-objects)). If the data contains only primitive values, do not define it.
     */
    textField?: string;
    /**
     * Renders a floating label for the MultiSelect.
     */
    label?: string;
    /**
     * Configures the popup of the MultiSelect.
     */
    popupSettings?: DropDownsPopupSettings;
    /**
     * Configures the virtual scrolling of the MultiSelect ([see example]({% slug virtualization_multiselect %})).
     */
    virtual?: VirtualizationSettings;
    /**
     * Fires each time the popup of the MultiSelect is about to open.
     */
    onOpen?: (event: MultiSelectOpenEvent) => void;
    /**
     * Fires each time the popup of the MultiSelect is about to close.
     */
    onClose?: (event: MultiSelectCloseEvent) => void;
    /**
     * Fires each time the user focuses the MultiSelect.
     */
    onFocus?: (event: MultiSelectFocusEvent) => void;
    /**
     * Fires each time the MultiSelect gets blurred.
     */
    onBlur?: (event: MultiSelectBlurEvent) => void;
    /**
     * Fires each time the value of the MultiSelect is about to change ([see examples]({% slug binding_multiselect %})).
     */
    onChange?: (event: MultiSelectChangeEvent) => void;
    /**
     * Fires each time the user types in the filter input ([see example]({% slug filtering_multiselect %}#toc-basic-configuration)). You can filter the source based on the passed filtration value.
     */
    onFilterchange?: (event: MultiSelectFilterChangeEvent) => void;
    /**
     * Fires when both the virtual scrolling of the MultiSelect is enabled and when the component requires data for another page ([see example]({% slug virtualization_multiselect %})).
     */
    onPagechange?: (event: MultiSelectPageChangeEvent) => void;
    /**
     * Fires when a MultiSelect item is about to be rendered ([see example]({% slug customrendering_multiselect %}#toc-items)). Used to override the default appearance of the list items.
     */
    itemRender?: any;
    /**
     * Fires when the element which indicates no data in the popup is about to be rendered ([see example]({% slug customrendering_multiselect %}#toc-no-data)). Used to override the default appearance of the element.
     */
    listNoDataRender?: any;
    /**
     * Fires when a tag element is about to be rendered ([see example]({% slug customrendering_multiselect %}#toc-tags)). Used to override the default appearance of the element.
     */
    tagRender?: any;
    /**
     * Sets the header component of the MultiSelect ([see example]({% slug customrendering_multiselect %}#toc-headers-and-footers)).
     */
    header?: any;
    /**
     * Sets the footer component of the MultiSelect ([see example]({% slug customrendering_multiselect %}#toc-headers-and-footers)).
     */
    footer?: any;
    /**
     * Configures the `size` of the MultiSelect.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - null&mdash;Does not set a size `class`.
     *
     * @default `medium`
     */
    size?: null | 'small' | 'medium' | 'large' | string;
    /**
     * Configures the `roundness` of the MultiSelect.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - full
     * - null&mdash;Does not set a rounded `class`.
     *
     * @default `medium`
     */
    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `roundness` of the tags in MultiSelect.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - circle
     * - full
     * - null&mdash;Does not set a rounded `class`.
     *
     * @default `medium`
     */
    tagsRounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `fillMode` of the MultiSelect.
     *
     * The available options are:
     * - solid
     * - outline
     * - flat
     * - link
     * - null&mdash;Does not set a fillMode `class`.
     *
     * @default `solid`
     */
    fillMode?: null | 'solid' | 'outline' | 'flat' | string;
    /**
     * Sets the data item field that represents the start of a group. Applicable to objects data.
     */
    groupField?: string;
    /**
     * Fires when a MultiSelect group header item is about to be rendered. Used to override the default appearance of the group's headers.
     */
    groupHeaderItemRender?: any;
    /**
     * Fires when a MultiSelect sticky group header item is about to be rendered. Used to override the default appearance of the sticky group header of the component.
     */
    groupStickyHeaderItemRender?: any;
    /**
     * Provides different rendering of the popup element based on the screen dimensions.
     */
    adaptive?: boolean;
    /**
     * Specifies the text that is rendered as title in the adaptive popup.
     */
    adaptiveTitle?: string;
    /**
     * Sets the built-in HTML attributes of the inner focusable input element.
     * Attributes which are essential for certain component functionalities cannot be changed.
     */
    inputAttributes?: Object;
}

/**
 * Represents the tag data.
 */
export declare interface MultiSelectTagData {
    /**
     * Represents the text of the tag.
     */
    text: string;
    /**
     * Represents the data items which correspond to the tag.
     */
    data: Array<any>;
}

/**
 * @hidden
 */
export declare const MultiSelectTree: DefineComponent<ExtractPropTypes<    {
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: PropType<string>;
tabIndex: PropType<number>;
accessKey: PropType<string>;
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
value: PropType<any[]>;
modelValue: PropType<any[]>;
valueMap: PropType<(value: any[]) => any>;
placeholder: PropType<string>;
dataItemKey: {
type: PropType<string>;
required: true;
};
textField: {
type: PropType<string>;
required: true;
};
checkField: {
type: PropType<string>;
default: string;
};
checkIndeterminateField: {
type: PropType<string>;
default: string;
};
expandField: PropType<string>;
subItemsField: {
type: PropType<string>;
default: string;
};
className: PropType<string>;
label: PropType<string>;
validationMessage: PropType<string>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
required: PropType<boolean>;
name: PropType<string>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
filterable: PropType<boolean>;
filter: PropType<string>;
loading: PropType<boolean>;
tags: PropType<MultiSelectTagData[]>;
popupSettings: {
type: PropType<DropDownsPopupSettings_3>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
item: PropType<any>;
tag: PropType<any>;
header: PropType<any>;
footer: PropType<any>;
listNoData: PropType<any>;
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
}>, {}, {
focusedTagState: any;
openState: boolean;
focusedState: boolean;
filterState: string;
currentValue: any[];
popupWidth: string;
windowWidth: number;
initialAdaptiveRenderingValues: any;
}, {
animationStyles(): object | undefined;
classNameAdaptive(): string;
adaptiveState(): any;
isOpen(): any;
computedValue(): any;
hasValue(): boolean;
tagsToRenderRef(): any;
}, {
clearFilter(event: MultiSelectTreeCloseEvent): void;
onCancel(event: MouseEvent): void;
calculateMedia(entries: ResizeObserverEntry[]): void;
calculatePopupWidth(): void;
focus(): void;
setValidity(): void;
changeValue(event: DropdownEvent, items: any[], operation: MultiSelectTreeChangeEventOperation): void;
onChange(e: TreeViewItemClickEvent): void;
openPopup(event: MultiSelectTreeCloseEvent): void;
closePopup(event: MultiSelectTreeCloseEvent): void;
switchFocus(focusFn: () => void): void;
focusElement(element: HTMLElement | null): void;
onPopupOpened(): void;
onPopupClosed(): void;
onFocus(event: any): void;
onBlur(event: any): void;
onWrapperMouseDown(): void;
onWrapperClick(event: any): void;
onWrapperKeyDown(event: any): any;
onInputKeyDown(event: any): void;
onClear(event: any): void;
onTagDelete(itemsToRemove: Array<any>, event: any): void;
onExpand(e: TreeViewExpandChangeEvent): void;
onFilterChange(event: any, emptyValue?: boolean): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
open: any;
close: any;
focus: any;
blur: any;
change: any;
filterchange: any;
expandchange: any;
changemodel: any;
'update:modelValue': any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
opened: {
type: PropType<boolean>;
default: any;
};
disabled: PropType<boolean>;
dir: PropType<string>;
tabIndex: PropType<number>;
accessKey: PropType<string>;
dataItems: {
type: PropType<any[]>;
default: () => any[];
};
value: PropType<any[]>;
modelValue: PropType<any[]>;
valueMap: PropType<(value: any[]) => any>;
placeholder: PropType<string>;
dataItemKey: {
type: PropType<string>;
required: true;
};
textField: {
type: PropType<string>;
required: true;
};
checkField: {
type: PropType<string>;
default: string;
};
checkIndeterminateField: {
type: PropType<string>;
default: string;
};
expandField: PropType<string>;
subItemsField: {
type: PropType<string>;
default: string;
};
className: PropType<string>;
label: PropType<string>;
validationMessage: PropType<string>;
validityStyles: {
type: PropType<boolean>;
default: boolean;
};
valid: {
type: PropType<boolean>;
default: any;
};
required: PropType<boolean>;
name: PropType<string>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
filterable: PropType<boolean>;
filter: PropType<string>;
loading: PropType<boolean>;
tags: PropType<MultiSelectTagData[]>;
popupSettings: {
type: PropType<DropDownsPopupSettings_3>;
default: () => {
animate: boolean;
height: string;
anchor: string;
};
};
size: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
rounded: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
fillMode: {
type: PropType<string>;
default: string;
validator: (value: any) => any;
};
item: PropType<any>;
tag: PropType<any>;
header: PropType<any>;
footer: PropType<any>;
listNoData: PropType<any>;
adaptive: {
type: PropType<boolean>;
default: any;
};
adaptiveTitle: {
type: PropType<string>;
default: any;
};
}>> & Readonly<{
onBlur?: (...args: any[] | unknown[]) => any;
onChange?: (...args: any[] | unknown[]) => any;
onClose?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onOpen?: (...args: any[] | unknown[]) => any;
onChangemodel?: (...args: any[] | unknown[]) => any;
"onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
onFilterchange?: (...args: any[] | unknown[]) => any;
onExpandchange?: (...args: any[] | unknown[]) => any;
}>, {
size: string;
rounded: string;
fillMode: string;
dataItems: any[];
opened: boolean;
popupSettings: DropDownsPopupSettings_3;
valid: boolean;
validityStyles: boolean;
adaptive: boolean;
adaptiveTitle: string;
checkIndeterminateField: string;
checkField: string;
subItemsField: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the object of the `onBlur` MultiSelectTree event.
 */
export declare interface MultiSelectTreeBlurEvent extends BlurEvent {
}

/**
 * Represents the object of the `onChange` MultiSelectTree event.
 */
export declare interface MultiSelectTreeChangeEvent extends DropdownEvent {
    /**
     * The items related to current operation.
     */
    items: any[];
    /**
     * The new value.
     */
    value: any[];
    /**
     * Describes the current operation:
     * * `clear` - clear button is clicked and value is cleared. Null value is returned.
     * * `delete` - tag is deleted using keyboard or mouse. The items contained in current tag are returned.
     * * `toggle` - item in TreeView is toggled. Single item is returned.
     */
    operation: MultiSelectTreeChangeEventOperation;
}

export declare type MultiSelectTreeChangeEventOperation = 'clear' | 'delete' | 'toggle';

/**
 * Represents the object of the `onClose` MultiSelectTree event.
 */
export declare interface MultiSelectTreeCloseEvent extends CloseEvent_2 {
}

/**
 * Represents the object of the `onExpandChange` MultiSelectTree event.
 */
export declare interface MultiSelectTreeExpandEvent extends DropdownEvent {
    item: any;
    level: number[];
}

/**
 * Represents the object of the `onFilterChange` MultiSelectTree event.
 */
export declare interface MultiSelectTreeFilterChangeEvent extends FilterChangeEvent {
}

/**
 * Represents the object of the `onFocus` MultiSelectTree event.
 */
export declare interface MultiSelectTreeFocusEvent extends FocusEvent_2 {
}

/**
 * The props of component that will be used for rendering each of the MultiSelectTree items
 * ([see example]({% slug customrendering_multiselecttree %}#toc-items-and-value-element)).
 */
export declare interface MultiSelectTreeItemProps extends ItemRenderProps {
}

/**
 * The props of the `ListNoData` component ([see example]({% slug customrendering_multiselecttree %}#toc-no-data)).
 */
export declare interface MultiSelectTreeListNoDataProps {
}

/**
 * Represents the object of the `onOpen` MultiSelectTree event.
 */
export declare interface MultiSelectTreeOpenEvent extends OpenEvent {
}

/**
 * Represents the props of the [Kendo UI for Vue MultiSelectTree component]({% slug overview_multiselecttree %}).
 */
export declare interface MultiSelectTreeProps extends FormComponentProps {
    /**
     * Sets the data of the MultiSelectTree ([see example]({% slug overview_multiselecttree %})).
     */
    dataItems?: any[];
    /**
     * Sets the opened state of the MultiSelectTree.
     */
    opened?: boolean;
    /**
     * Sets the value of the MultiSelectTree. It can either be an array of the primitive (string, numbers) or of the complex (objects) type.
     */
    value?: Array<any>;
    /**
     * Sets the modelValue of the MultiSelectTree. It can either be an array of the primitive (string, numbers) or of the complex (objects) type.
     */
    modelValue?: Array<any>;
    /**
     * The hint that is displayed when the MultiSelectTree is empty.
     */
    placeholder?: string;
    /**
     * Sets the key for comparing the data items of the MultiSelectTree ([see example]({% slug overview_multiselecttree %})).
     * If `dataItemKey` is not set, the MultiSelectTree compares the items by reference.
     */
    dataItemKey: string;
    /**
     * Sets additional classes to the MultiSelectTree.
     */
    className?: string;
    /**
     * Sets the disabled state of the MultiSelectTree.
     */
    disabled?: boolean;
    /**
     * Represents the `dir` HTML attribute.
     */
    dir?: string;
    /**
     * Renders a floating label for the MultiSelectTree.
     */
    label?: string;
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Specifies the validationMessage of the component.
     */
    validationMessage?: string;
    /**
     * If set to `false`, no visual representation of the invalid state of the component will be applied.
     *
     */
    validityStyles?: boolean;
    /**
     * Overrides the validity state of the component.
     * If `valid` is set, the `required` property will be ignored.
     *
     */
    valid?: boolean;
    /**
     * Specifies the `name` property of the `input` DOM element.
     *
     */
    name?: string;
    /**
     * Specifies if `null` is a valid value for the component.
     *
     */
    required?: boolean;
    /**
     * Sets the tags of the MultiSelect ([see example]({% slug customtags_multiselect %})).
     */
    tags?: Array<MultiSelectTagData>;
    /**
     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
     * For example these elements could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Enables the filtering functionality of the MultiSelectTree ([more information and examples]({% slug filtering_multiselecttree %})).
     */
    filterable?: boolean;
    /**
     * Sets the value of filtering input.
     * Useful for making the filtering input a controlled component.
     */
    filter?: string;
    /**
     * Sets the loading state of the MultiSelectTree ([see example]({% slug filtering_multiselecttree %}#toc-visualize-filtering)).
     */
    loading?: boolean;
    /**
     * Specifies the `tabIndex` of the MultiSelectTree.
     */
    tabIndex?: number;
    /**
     * Specifies the `accessKey` of the MultiSelectTree.
     */
    accessKey?: string;
    /**
     * Sets the data item field that represents the item text ([see example]({% slug overview_multiselecttree %})).
     */
    textField: string;
    /**
     * Specifies the name of the field which will provide a Boolean representation of the checked state of the item.
     */
    checkField?: string;
    /**
     * Specifies the name of the field which will provide a Boolean representation of the checked indeterminaet state of the item.
     */
    checkIndeterminateField?: string;
    /**
     * Specifies the name of the field which will provide a Boolean representation of the expanded state of the item.
     */
    expandField?: string;
    /**
     * Specifies the name of the field which will provide an array representation of the item subitems.
     * Defaults to 'items'.
     */
    subItemsField?: string;
    /**
     * Configures the popup of the MultiSelectTree.
     */
    popupSettings?: DropDownsPopupSettings;
    /**
     * Represents a callback function, which returns the value for submitting. The returned value will be rendered in an `option` of a hidden `select` element.
     *
     * @example
     * ```jsx-no-run
     * class App extends React.Component {
     *    render() {
     *       return (
     *          <form>
     *              <MultiSelectTree
     *                  data={[ { text: "Austria", id: 1 } , { text: "Belarus", id: 2 } ]}
     *                  valueMap={value => value && value.id}
     *              />
     *              <button type="submit">Submit</button>
     *          </form>
     *       );
     *    }
     * }
     * ReactDOM.render(<App />, document.querySelector('my-app'));
     * ```
     */
    valueMap?: (value: Array<any>) => any;
    /**
     * Fires each time the popup of the MultiSelectTree is about to open.
     */
    onOpen?: (event: MultiSelectTreeOpenEvent) => void;
    /**
     * Fires each time the popup of the MultiSelectTree is about to close.
     */
    onClose?: (event: MultiSelectTreeCloseEvent) => void;
    /**
     * Fires each time the user focuses the MultiSelectTree.
     */
    onFocus?: (event: MultiSelectTreeFocusEvent) => void;
    /**
     * Fires each time the MultiSelectTree gets blurred.
     */
    onBlur?: (event: MultiSelectTreeBlurEvent) => void;
    /**
     * Fires each time the value of the MultiSelectTree is about to change ([see examples]({% slug overview_multiselecttree %})).
     */
    onChange?: (event: MultiSelectTreeChangeEvent) => void;
    /**
     * Fires each time the user types in the filter input
     * ([see example]({% slug filtering_multiselecttree %}#toc-basic-configuration)).
     * You can filter the source based on the passed filtration value.
     */
    onFilterChange?: (event: MultiSelectTreeFilterChangeEvent) => void;
    /**
     * Fires when the expanding or collapsing of an item is requested ([see examples]({% slug overview_multiselecttree %})).
     */
    onExpandChange?: (event: any) => void;
    /**
     * Defines the component that will be used for rendering each of the MultiSelectTree items
     * ([see example]({% slug customrendering_multiselecttree %}#toc-items-and-value-element)).
     */
    item?: any;
    /**
     * Defines the component that will be rendered in the MultiSelectTree popup when no data is available
     * ([see example]({% slug customrendering_multiselecttree %}#toc-no-data)).
     */
    listNoData?: any;
    tag?: any;
    header?: any;
    footer?: any;
    /**
     * Configures the `size` of the MultiSelectTree.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - null&mdash;Does not set a size `className`.
     *
     * @default `medium`
     */
    size?: null | 'small' | 'medium' | 'large' | string;
    /**
     * Configures the `roundness` of the MultiSelectTree.
     *
     * The available options are:
     * - small
     * - medium
     * - large
     * - full
     * - null&mdash;Does not set a rounded `className`.
     *
     * @default `medium`
     */
    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
    /**
     * Configures the `fillMode` of the MultiSelectTree.
     *
     * The available options are:
     * - solid
     * - flat
     * - outline
     * - null&mdash;Does not set a fillMode `className`.
     *
     * @default `solid`
     */
    fillMode?: null | 'solid' | 'flat' | 'outline' | string;
    /**
     * Provides different rendering of the popup element based on the screen dimensions.
     */
    adaptive?: boolean;
    /**
     * Specifies the text that is rendered as title in the adaptive popup.
     */
    adaptiveTitle?: string;
}

/**
 * The props of component that will be used for rendering each of the MultiSelectTree tags
 */
export declare interface MultiSelectTreeTagProps {
    tagData: MultiSelectTagData;
    guid: string;
    focusedTag?: MultiSelectTagData;
    onTagDelete: (items: Array<any>, event: any) => void;
}

/**
 * @hidden
 */
declare interface OpenEvent extends DropdownEvent {
}

/**
 * Represents the `skip` and `take` configurations which are wrapped in the `page` object.
 */
export declare interface Page {
    /**
     * The number of records to skip.
     */
    skip: number;
    /**
     * The number of records to take.
     */
    take: number;
}

/**
 * @hidden
 */
declare interface PageChangeEvent extends DropdownEvent {
    page: Page;
}

/**
 * Represents the `Suggestion` object of the AutoComplete.
 */
export declare interface Suggestion {
    /**
     * Represents the typed text of the user.
     */
    readonly userInput: string;
    /**
     * Represents the suggested text without the user input.
     */
    readonly value: string;
}

/**
 * The props of the `ValueHolder` component ([see example]({% slug customrendering_dropdowntree %}#toc-items-and-value-element)).
 */
export declare interface ValueHolderProps {
    item?: any;
}

/**
 * The virtualization settings.
 */
export declare interface VirtualizationSettings {
    /**
     * The number of the requested records.
     */
    pageSize: number;
    /**
     * The number of records to skip.
     */
    skip: number;
    /**
     * The number of all records.
     */
    total: number;
}

export { }