/*!
    *
    * Wijmo Library 5.20251.40
    * https://developer.mescius.com/wijmo
    *
    * Copyright(c) MESCIUS inc. All rights reserved.
    *
    * Licensed under the End-User License Agreement For MESCIUS Wijmo Software.
    * us.sales@mescius.com
    * https://developer.mescius.com/wijmo/licensing
    *
    */
/**
 * {@module wijmo.react.input}
 * Contains React components for the <b>wijmo.input</b> module.
 */
/**
 *
 */
export declare var ___keepComment: any;
import { ControlBaseEvents, ControlBaseInputs, WjRef, BaseInputs, WjForwardRefExoticComponent } from 'wijmo/wijmo.react.base';
import * as wjcCore from 'wijmo/wijmo';
import * as wjcInput from 'wijmo/wijmo.input';
export declare type ListBoxInputs = ControlBaseInputs & {
    caseSensitiveSearch?: boolean;
    checkedItems?: any[];
    checkedMemberPath?: string;
    displayMemberPath?: string;
    isContentHtml?: boolean;
    itemFormatter?: wjcInput.IItemFormatter;
    itemRole?: string;
    itemsSource?: wjcCore.ICollectionView | any[];
    maxHeight?: number;
    selectedIndex?: number;
    selectedItem?: any;
    selectedValue?: any;
    selectedValuePath?: string;
    showGroups?: boolean;
    ariaLabelledBy?: string;
    virtualizationThreshold?: number;
    wjItemTemplate?: ItemTemplateRender;
};
export declare type ListBoxEvents<T> = ControlBaseEvents<T> & {
    checkedItemsChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    formatItem?: wjcCore.IEventHandler<T, wjcInput.FormatItemEventArgs>;
    itemChecked?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    itemsChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    loadedItems?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    loadingItems?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    selectedIndexChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const ListBoxMeta: {
    inputs: string[];
    events: string[];
};
export declare type ListBoxProps = ListBoxInputs & ListBoxEvents<wjcInput.ListBox>;
export declare type ListBoxRef = WjRef<wjcInput.ListBox>;
/**
 * React component for the {@link wijmo.input.ListBox} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.ListBox} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 *
 * The component includes a <b>wjItemTemplate</b> property which is used to define list item template.
 * The template is a function with single argument. The argument is a plain object with keys of
 * <b>control</b> (list control, owner of the list item),
 * <b>item</b> (item data for the list item) and
 * <b>itemIndex</b> (zero-based index of the list item).
 */
export declare const ListBox: WjForwardRefExoticComponent<ListBoxProps>;
export declare type MultiSelectListBoxInputs = ControlBaseInputs & {
    caseSensitiveSearch?: boolean;
    checkOnFilter?: boolean;
    checkedItems?: any[];
    checkedMemberPath?: string;
    delay?: number;
    displayMemberPath?: string;
    filterInputPlaceholder?: string;
    isContentHtml?: boolean;
    itemsSource?: wjcCore.ICollectionView | any[];
    selectAllLabel?: string;
    selectedIndex?: number;
    showFilterInput?: boolean;
    showGroups?: boolean;
    showSelectAllCheckbox?: boolean;
    virtualizationThreshold?: number;
    wjItemTemplate?: ItemTemplateRender;
};
export declare type MultiSelectListBoxEvents<T> = ControlBaseEvents<T> & {
    checkedItemsChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    selectedIndexChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const MultiSelectListBoxMeta: {
    inputs: string[];
    events: string[];
};
export declare type MultiSelectListBoxProps = MultiSelectListBoxInputs & MultiSelectListBoxEvents<wjcInput.MultiSelectListBox>;
export declare type MultiSelectListBoxRef = WjRef<wjcInput.MultiSelectListBox>;
/**
 * React component for the {@link wijmo.input.MultiSelectListBox} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.MultiSelectListBox} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const MultiSelectListBox: WjForwardRefExoticComponent<MultiSelectListBoxProps>;
export declare type DropDownInputs = ControlBaseInputs & {
    autoExpandSelection?: boolean;
    clickAction?: wjcInput.ClickAction | string;
    dropDownCssClass?: string;
    inputType?: string;
    isAnimated?: boolean;
    isDroppedDown?: boolean;
    isReadOnly?: boolean;
    isRequired?: boolean;
    placeholder?: string;
    showDropDownButton?: boolean;
    text?: string | null;
};
export declare type DropDownEvents<T> = ControlBaseEvents<T> & {
    isDroppedDownChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    isDroppedDownChanging?: wjcCore.IEventHandler<T, wjcCore.CancelEventArgs>;
    textChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const DropDownMeta: {
    inputs: string[];
    events: string[];
};
export declare type ComboBoxInputs = DropDownInputs & {
    caseSensitiveSearch?: boolean;
    displayMemberPath?: string;
    handleWheel?: boolean;
    headerPath?: string | null;
    isContentHtml?: boolean;
    isEditable?: boolean;
    itemFormatter?: wjcInput.IItemFormatter;
    itemsSource?: any[] | wjcCore.ICollectionView;
    maxDropDownHeight?: number;
    maxDropDownWidth?: number;
    selectedIndex?: number;
    selectedItem?: any;
    selectedValue?: any;
    selectedValuePath?: string;
    showGroups?: boolean;
    trimText?: boolean;
    virtualizationThreshold?: number;
    wjItemTemplate?: ItemTemplateRender;
    ariaLabelledBy?: string;
    keyActionDownArrow?: wjcInput.KeyAction | number;
    keyActionUpArrow?: wjcInput.KeyAction | number;
    keyActionPrintCharacters?: wjcInput.KeyAction | number;
    keyActionTab?: wjcInput.TabKeyAction | number;
};
export declare type ComboBoxEvents<T> = DropDownEvents<T> & {
    formatItem?: wjcCore.IEventHandler<T, wjcInput.FormatItemEventArgs>;
    itemsSourceChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    selectedIndexChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const ComboBoxMeta: {
    inputs: string[];
    events: string[];
};
export declare type ComboBoxProps = ComboBoxInputs & ComboBoxEvents<wjcInput.ComboBox>;
export declare type ComboBoxRef = WjRef<wjcInput.ComboBox>;
/**
 * React component for the {@link wijmo.input.ComboBox} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.ComboBox} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 *
 * The component includes a <b>wjItemTemplate</b> property which is used to define list item template.
 * The template is a function with single argument. The argument is a plain object with keys of
 * <b>control</b> (list control, owner of the list item),
 * <b>item</b> (item data for the list item) and
 * <b>itemIndex</b> (zero-based index of the list item).
 */
export declare const ComboBox: WjForwardRefExoticComponent<ComboBoxProps>;
export declare type AutoCompleteInputs = ComboBoxInputs & {
    beginsWithSearch?: boolean;
    cssMatch?: string;
    delay?: number;
    itemsSourceFunction?: wjcInput.IGetItems;
    maxItems?: number;
    minLength?: number;
    searchMemberPath?: string;
};
export declare type AutoCompleteEvents<T> = ComboBoxEvents<T> & {};
export declare const AutoCompleteMeta: {
    inputs: string[];
    events: string[];
};
export declare type AutoCompleteProps = AutoCompleteInputs & AutoCompleteEvents<wjcInput.AutoComplete>;
export declare type AutoCompleteRef = WjRef<wjcInput.AutoComplete>;
/**
 * React component for the {@link wijmo.input.AutoComplete} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.AutoComplete} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const AutoComplete: WjForwardRefExoticComponent<AutoCompleteProps>;
export declare type CalendarInputs = ControlBaseInputs & {
    displayMonth?: Date;
    firstDayOfWeek?: number | null;
    formatDayHeaders?: string;
    formatDays?: string;
    formatMonths?: string;
    formatYear?: string;
    formatYearMonth?: string;
    handleWheel?: boolean;
    isReadOnly?: boolean;
    itemFormatter?: wjcInput.IDateFormatter | null;
    itemValidator?: wjcInput.IDateValidator | null;
    max?: Date | null;
    min?: Date | null;
    monthCount?: number;
    monthView?: boolean;
    rangeEnd?: Date;
    rangeMax?: number;
    rangeMin?: number;
    repeatButtons?: boolean;
    selectionMode?: wjcInput.DateSelectionMode;
    showHeader?: boolean;
    showMonthPicker?: boolean | wjcInput.ShowMonthPicker;
    showYearPicker?: boolean;
    value?: Date;
    weeksAfter?: number;
    weeksBefore?: number;
};
export declare type CalendarEvents<T> = ControlBaseEvents<T> & {
    displayMonthChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    formatItem?: wjcCore.IEventHandler<T, wjcInput.FormatItemEventArgs>;
    rangeChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    rangeEndChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const CalendarMeta: {
    inputs: string[];
    events: string[];
};
export declare type CalendarProps = CalendarInputs & CalendarEvents<wjcInput.Calendar>;
export declare type CalendarRef = WjRef<wjcInput.Calendar>;
/**
 * React component for the {@link wijmo.input.Calendar} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.Calendar} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const Calendar: WjForwardRefExoticComponent<CalendarProps>;
export declare type ColorPickerInputs = ControlBaseInputs & {
    palette?: string[];
    showAlphaChannel?: boolean;
    showColorString?: boolean;
    value?: string;
};
export declare type ColorPickerEvents<T> = ControlBaseEvents<T> & {
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const ColorPickerMeta: {
    inputs: string[];
    events: string[];
};
export declare type ColorPickerProps = ColorPickerInputs & ColorPickerEvents<wjcInput.ColorPicker>;
export declare type ColorPickerRef = WjRef<wjcInput.ColorPicker>;
/**
 * React component for the {@link wijmo.input.ColorPicker} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.ColorPicker} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const ColorPicker: WjForwardRefExoticComponent<ColorPickerProps>;
export declare type InputMaskInputs = ControlBaseInputs & {
    inputType?: string;
    isReadOnly?: boolean;
    isRequired?: boolean;
    mask?: string;
    overwriteMode?: boolean;
    placeholder?: string;
    promptChar?: string;
    rawValue?: string;
    value?: string;
};
export declare type InputMaskEvents<T> = ControlBaseEvents<T> & {
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const InputMaskMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputMaskProps = InputMaskInputs & InputMaskEvents<wjcInput.InputMask>;
export declare type InputMaskRef = WjRef<wjcInput.InputMask>;
/**
 * React component for the {@link wijmo.input.InputMask} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputMask} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputMask: WjForwardRefExoticComponent<InputMaskProps>;
export declare type InputColorInputs = DropDownInputs & {
    palette?: string[];
    showAlphaChannel?: boolean;
    showColorString?: boolean;
    text?: string;
    value?: string;
};
export declare type InputColorEvents<T> = DropDownEvents<T> & {
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const InputColorMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputColorProps = InputColorInputs & InputColorEvents<wjcInput.InputColor>;
export declare type InputColorRef = WjRef<wjcInput.InputColor>;
/**
 * React component for the {@link wijmo.input.InputColor} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputColor} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputColor: WjForwardRefExoticComponent<InputColorProps>;
export declare type MultiSelectInputs = ComboBoxInputs & {
    caseSensitiveSearch?: boolean;
    checkOnFilter?: boolean;
    checkedItems?: any[];
    checkedMemberPath?: string;
    delay?: number;
    filterInputPlaceholder?: string | null;
    headerFormat?: string | null;
    headerFormatter?: wjcInput.IHeaderFormatter | null;
    maxHeaderItems?: number;
    selectAllLabel?: string | null;
    showFilterInput?: boolean;
    showSelectAllCheckbox?: boolean;
};
export declare type MultiSelectEvents<T> = ComboBoxEvents<T> & {
    checkedItemsChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const MultiSelectMeta: {
    inputs: string[];
    events: string[];
};
export declare type MultiSelectProps = MultiSelectInputs & MultiSelectEvents<wjcInput.MultiSelect>;
export declare type MultiSelectRef = WjRef<wjcInput.MultiSelect>;
/**
 * React component for the {@link wijmo.input.MultiSelect} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.MultiSelect} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 *
 * The component includes a <b>wjItemTemplate</b> property which is used to define list item template.
 * The template is a function with single argument. The argument is a plain object with keys of
 * <b>control</b> (list control, owner of the list item),
 * <b>item</b> (item data for the list item) and
 * <b>itemIndex</b> (zero-based index of the list item).
 */
export declare const MultiSelect: WjForwardRefExoticComponent<MultiSelectProps>;
export declare type MultiAutoCompleteInputs = AutoCompleteInputs & {
    maxSelectedItems?: number;
    selectedItems?: any[];
    selectedMemberPath?: string;
    showDropDownButton?: boolean;
};
export declare type MultiAutoCompleteEvents<T> = AutoCompleteEvents<T> & {
    selectedItemsChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const MultiAutoCompleteMeta: {
    inputs: string[];
    events: string[];
};
export declare type MultiAutoCompleteProps = MultiAutoCompleteInputs & MultiAutoCompleteEvents<wjcInput.MultiAutoComplete>;
export declare type MultiAutoCompleteRef = WjRef<wjcInput.MultiAutoComplete>;
/**
 * React component for the {@link wijmo.input.MultiAutoComplete} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.MultiAutoComplete} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const MultiAutoComplete: WjForwardRefExoticComponent<MultiAutoCompleteProps>;
export declare type InputNumberInputs = ControlBaseInputs & {
    format?: string;
    handleWheel?: boolean;
    inputType?: string;
    isReadOnly?: boolean;
    isRequired?: boolean;
    max?: number | null;
    min?: number | null;
    placeholder?: string;
    repeatButtons?: boolean;
    showSpinner?: boolean;
    step?: number | null;
    text?: string;
    value?: number | null;
    ariaLabelledBy?: string;
};
export declare type InputNumberEvents<T> = ControlBaseEvents<T> & {
    textChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const InputNumberMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputNumberProps = InputNumberInputs & InputNumberEvents<wjcInput.InputNumber>;
export declare type InputNumberRef = WjRef<wjcInput.InputNumber>;
/**
 * React component for the {@link wijmo.input.InputNumber} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputNumber} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputNumber: WjForwardRefExoticComponent<InputNumberProps>;
export declare type InputDateInputs = DropDownInputs & {
    alwaysShowCalendar?: boolean;
    closeOnSelection?: boolean;
    format?: string;
    handleWheel?: boolean;
    inputType?: string;
    itemFormatter?: wjcInput.IDateFormatter;
    itemValidator?: wjcInput.IDateValidator;
    mask?: string;
    max?: Date | null;
    min?: Date | null;
    monthCount?: number;
    predefinedRanges?: any;
    rangeEnd?: Date;
    rangeMax?: number;
    rangeMin?: number;
    repeatButtons?: boolean;
    selectionMode?: wjcInput.DateSelectionMode | string;
    separator?: string;
    showHeader?: boolean;
    showMonthPicker?: boolean | wjcInput.ShowMonthPicker | string;
    showYearPicker?: boolean;
    text?: string;
    value?: Date | null;
    weeksAfter?: number;
    weeksBefore?: number;
    keepInvalidText?: boolean;
    preserveCalendarNavigation?: boolean;
};
export declare type InputDateEvents<T> = DropDownEvents<T> & {
    rangeChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    rangeEndChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const InputDateMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputDateProps = InputDateInputs & InputDateEvents<wjcInput.InputDate>;
export declare type InputDateRef = WjRef<wjcInput.InputDate>;
/**
 * React component for the {@link wijmo.input.InputDate} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputDate} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputDate: WjForwardRefExoticComponent<InputDateProps>;
export declare type InputTimeInputs = ComboBoxInputs & {
    format?: string;
    inputType?: string;
    mask?: string;
    max?: Date | string | null;
    min?: Date | string | null;
    step?: number | null;
    text?: string;
    value?: Date | null;
};
export declare type InputTimeEvents<T> = ComboBoxEvents<T> & {
    valueChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const InputTimeMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputTimeProps = InputTimeInputs & InputTimeEvents<wjcInput.InputTime>;
export declare type InputTimeRef = WjRef<wjcInput.InputTime>;
/**
 * React component for the {@link wijmo.input.InputTime} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputTime} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputTime: WjForwardRefExoticComponent<InputTimeProps>;
export declare type InputDateTimeInputs = InputDateInputs & {
    timeFormat?: string;
    timeMax?: Date;
    timeMin?: Date;
    timeStep?: number | null;
};
export declare type InputDateTimeEvents<T> = InputDateEvents<T> & {};
export declare const InputDateTimeMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputDateTimeProps = InputDateTimeInputs & InputDateTimeEvents<wjcInput.InputDateTime>;
export declare type InputDateTimeRef = WjRef<wjcInput.InputDateTime>;
/**
 * React component for the {@link wijmo.input.InputDateTime} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputDateTime} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputDateTime: WjForwardRefExoticComponent<InputDateTimeProps>;
export declare type InputDateRangeInputs = InputDateInputs & {};
export declare type InputDateRangeEvents<T> = InputDateEvents<T> & {};
export declare const InputDateRangeMeta: {
    inputs: string[];
    events: string[];
};
export declare type InputDateRangeProps = InputDateRangeInputs & InputDateRangeEvents<wjcInput.InputDateRange>;
export declare type InputDateRangeRef = WjRef<wjcInput.InputDateRange>;
/**
 * React component for the {@link wijmo.input.InputDateRange} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.InputDateRange} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const InputDateRange: WjForwardRefExoticComponent<InputDateRangeProps>;
export declare type MenuInputs = ComboBoxInputs & {
    closeOnLeave?: boolean;
    command?: wjcInput.ICommand | null;
    commandParameterPath?: string;
    commandPath?: string;
    header?: string;
    isButton?: boolean;
    openOnHover?: boolean;
    owner?: HTMLElement;
    subItemsPath?: string;
    contextMenuOf?: any;
    ariaLabel?: string;
    autoSelectOnFocus?: boolean;
    value?: any;
};
export declare type MenuEvents<T> = ComboBoxEvents<T> & {
    itemClicked?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
};
export declare const MenuMeta: {
    inputs: string[];
    events: string[];
};
export declare type MenuProps = MenuInputs & MenuEvents<wjcInput.Menu>;
export declare type MenuRef = WjRef<wjcInput.Menu>;
/**
 * React component for the {@link wijmo.input.Menu} control.
 *
 * The <b>menu</b> component may contain
 * the following child components:
 * {@link wijmo.react.input.MenuItem}
 * and {@link wijmo.react.input.MenuSeparator}.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.Menu} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 *
 * The component includes a <b>wjItemTemplate</b> property which is used to define list item template.
 * The template is a function with single argument. The argument is a plain object with keys of
 * <b>control</b> (list control, owner of the list item),
 * <b>item</b> (item data for the list item) and
 * <b>itemIndex</b> (zero-based index of the list item).
 *
 * The component includes a <b>contextMenuOf</b> property which is used to assign context menu to elements or controls.
 * Value of the property can be id attribute of HTMLElement, reference or array of HTMLElement/ReactComponent.
 */
export declare const Menu: WjForwardRefExoticComponent<MenuProps>;
export declare type MenuItemInputs = BaseInputs & {
    cmd?: any;
    cmdParam?: any;
    value?: any;
    children?: any;
};
export declare type MenuItemEvents<T> = {};
export declare const MenuItemMeta: {
    inputs: string[];
    events: any[];
};
declare class _MenuItem {
    _parent: wjcInput.Menu;
    children: any;
    value: any;
    cmd: any;
    cmdParam: any;
    header: any;
    itemRoot: HTMLElement;
    constructor(parent: any, options: any);
    private _init;
    updateItem(hostEl: any): void;
}
export declare type MenuItemProps = MenuItemInputs & MenuItemEvents<_MenuItem>;
export declare type MenuItemRef = WjRef<_MenuItem>;
/**
 * React component that represents an item in a {@link wijmo.react.input.Menu} control.
 *
 * The <b>menu-item</b> component should be contained in
 * a {@link wijmo.react.input.Menu} component.
 *
 * The component supports all properties and events of the pure JavaScript {@link } class it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const MenuItem: WjForwardRefExoticComponent<MenuItemProps>;
export declare type MenuSeparatorProps = any;
export declare type MenuSeparatorRef = WjRef<_MenuSeparator>;
/**
 * React component that represents an item separator in a {@link wijmo.react.input.Menu} control.
 *
 * The <b>menu-separator</b> component should be contained in
 * a {@link wijmo.react.input.Menu} component.
 *
 * The component supports all properties and events of the pure JavaScript {@link } class it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const MenuSeparator: WjForwardRefExoticComponent<MenuSeparatorProps>;
declare class _MenuSeparator {
    constructor(parent: any, options: any);
    updateItem(hostEl: any): void;
}
export declare type PopupInputs = ControlBaseInputs & {
    content?: HTMLElement;
    dialogResult?: any;
    dialogResultEnter?: any;
    dialogResultSubmit?: string;
    fadeIn?: boolean;
    fadeOut?: boolean;
    hideTrigger?: wjcInput.PopupTrigger | string;
    isDraggable?: boolean;
    isResizable?: boolean;
    isVisible?: boolean;
    modal?: boolean;
    owner?: HTMLElement | null;
    position?: wjcCore.PopupPosition | string;
    removeOnHide?: boolean;
    showTrigger?: wjcInput.PopupTrigger | string;
    ariaLabelledBy?: string;
};
export declare type PopupEvents<T> = ControlBaseEvents<T> & {
    dragged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    dragging?: wjcCore.IEventHandler<T, wjcCore.CancelEventArgs>;
    hidden?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    hiding?: wjcCore.IEventHandler<T, wjcCore.CancelEventArgs>;
    positionChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    positionChanging?: wjcCore.IEventHandler<T, wjcInput.PopupBoundsChangingEventArgs>;
    resized?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    resizing?: wjcCore.IEventHandler<T, wjcCore.CancelEventArgs>;
    showing?: wjcCore.IEventHandler<T, wjcCore.CancelEventArgs>;
    shown?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    sizeChanged?: wjcCore.IEventHandler<T, wjcCore.EventArgs>;
    sizeChanging?: wjcCore.IEventHandler<T, wjcInput.PopupBoundsChangingEventArgs>;
};
export declare const PopupMeta: {
    inputs: string[];
    events: string[];
};
export declare type PopupProps = PopupInputs & PopupEvents<wjcInput.Popup>;
export declare type PopupRef = WjRef<wjcInput.Popup>;
/**
 * React component for the {@link wijmo.input.Popup} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.Popup} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const Popup: WjForwardRefExoticComponent<PopupProps>;
export declare type CollectionViewNavigatorInputs = ControlBaseInputs & {
    ariaLabel?: string;
    byPage?: boolean;
    cv?: wjcCore.CollectionView;
    headerFormat?: string;
    repeatButtons?: boolean;
};
export declare type CollectionViewNavigatorEvents<T> = ControlBaseEvents<T> & {};
export declare const CollectionViewNavigatorMeta: {
    inputs: string[];
    events: string[];
};
export declare type CollectionViewNavigatorProps = CollectionViewNavigatorInputs & CollectionViewNavigatorEvents<wjcInput.CollectionViewNavigator>;
export declare type CollectionViewNavigatorRef = WjRef<wjcInput.CollectionViewNavigator>;
/**
 * React component for the {@link wijmo.input.CollectionViewNavigator} control.
 *
 * The component supports all properties and events of the pure JavaScript {@link wijmo.input.CollectionViewNavigator} control it represents.
 *
 * The component includes an <b>initialized</b> event that is raised when the control is initialized after it is added to the page.
 * You can use this event to perform further initialization in addition to setting properties in JSX.
 * The signature of the handler function is the same as any other Wijmo event handlers.
 */
export declare const CollectionViewNavigator: WjForwardRefExoticComponent<CollectionViewNavigatorProps>;
/**
 * TBD
 */
export interface ItemTemplateContext {
    control: wjcCore.Control;
    item: any;
    itemIndex: number;
}
/**
 * TBD
 */
export declare type ItemTemplateRender = (context: ItemTemplateContext) => any;
export {};