import { EventEmitter } from '../../stencil-public-runtime';
import { ListboxPosition } from './exports';
/**
 * A select allows the user to choose between a set of options.
 * Overall behavior is based on native `<select>`
 *
 * @part value - interactive element showing the selected value (two occurrences: display and combobox wrapper).
 * @part label - label container for the select.
 * @part options - element that holds the option list / tooltip content.
 * @part message - element that renders hint/error messages.
 */
export declare class Select {
    host: HTMLRSelectElement;
    /** Specifies the `id` of the `<form>` to which the element belongs */
    form?: string;
    /** Specifies if element must be ignored during validation of the form elements */
    novalidate?: boolean;
    /** Name of element (data) within a form */
    name?: string;
    /** Selected value */
    value?: string;
    /** The text on the label */
    label: string;
    /** Specifies if the component is internal */
    internal?: boolean;
    /** Text that is presented until an option has been selected */
    placeholder?: string;
    /**
     * Optional hint, visually presented under the select,
     * giving additional context to the user
     */
    hint?: string;
    /** Prevent user interaction and apply disabled style */
    disabled?: boolean;
    /** Specifies that select value is required */
    required?: boolean;
    /** Text of an additional marker in the label */
    fieldIndicator?: string;
    /** Visual indication of valid state */
    valid?: boolean;
    /** Validity indicator, serving to change UI of the component */
    invalid?: boolean;
    /** Custom validation error message */
    error?: string;
    /** Define if select should render as a text item or a block */
    fullWidth: boolean;
    /** Define wether listbox appears on top or at the bottom of the select  */
    listboxPosition: ListboxPosition;
    /** Set custom message for `valueMissing` property of a ValidityState object (set by `required`) within Constrain Validation API */
    valueMissingMessage?: string;
    /** Set custom message for `customError` property of a ValidityState object indicating whether the element's custom validity message has been set to a non-empty string by calling the element's setCustomValidity() method. */
    customErrorMessage?: string;
    /** Defines if select is expanded */
    expanded?: boolean;
    /** Defines if select is in readonly state */
    readonly?: boolean;
    /**
     * Enable combobox functionality to allow users to reduce the list of options by filtering.
     */
    combobox?: boolean;
    /**
     * Defines aria label for combobox toggle button
     * @default "Toggle combobox"
     */
    toggleButtonAriaLabel?: string;
    /**
     * Defines the text that will be displayed if no results are found
     * @default "No results found"
     */
    noResultsFound?: string;
    /** Defines current state of listboxPosition */
    listboxPositionState: string;
    /** Custom validity state passed after validation */
    validityState: string;
    /** Custom validity message passed after validation */
    validityMessage: string;
    /** Is select expanded */
    isExpanded: boolean;
    /** Current state, reflecting if select is readonly */
    isReadonly: boolean;
    /** Save current value */
    currentValue: string;
    /** Value that must be displayed as selected option */
    valueToDisplay: string;
    isInitializing: boolean;
    isResetting: boolean;
    focusedOption: any;
    isValueFocused: boolean;
    isNoResultsFound: boolean;
    /** Indicates if the user has interacted with the select (focused/clicked) */
    touched: boolean;
    /** Indicates if the value has been changed by user interaction */
    dirty: boolean;
    /** Emits event after each validation */
    rValidate: EventEmitter<{
        state: string;
        message: string;
    }>;
    /** Emits `rChange` event when `<r-select>` value property changes */
    rChange: EventEmitter<{
        element: HTMLRSelectElement;
        value: any;
    }>;
    /** Emits `rReset` event when `<r-select>` onReset event happens */
    rReset: EventEmitter<{
        element: HTMLRSelectElement;
        value: any;
    }>;
    /** Emitted when the select receives focus */
    rFocus: EventEmitter;
    /** Emitted when the select loses focus */
    rBlur: EventEmitter;
    /** Sets the component into `readonly` state  */
    setReadonly(): Promise<void>;
    /** Clears readonly state from the component */
    clearReadonly(): Promise<void>;
    handleListboxPositionChange(): void;
    handleExpandedChange(): void;
    handleReadonlyChange(): void;
    handleValueChange(value: string | null, oldValue: string | null): void;
    /** Listen for custom event triggered by "onClick" event on `<r-select-option>` */
    optionSelectAction(e: any): void;
    tooltipFocusAction(): void;
    onMouseup(e: any): void;
    onKeyup(e: any): void;
    /**
     * Listen on window scroll
     * and update tooltip position if needed
     */
    handleScrolling(): void;
    /**
     * Listen on window resizing
     * and update tooltip position if needed
     */
    handleResizing(): void;
    /**
     * Set value of the select programmatically.
     * Does NOT mark as dirty or emit change events.
     * Use this for programmatic value updates.
     */
    setValue(value?: string): Promise<void>;
    /**
     * Internal method to set value from user interaction.
     * Assumes dirty flag is already set by the caller.
     * Will emit rChange if dirty flag is true.
     */
    private setValueFromUserInteraction;
    /** Set value of the select */
    getValue(): Promise<string>;
    /** Reset select to its initial state */
    reset(): Promise<void>;
    /**
     * Clears validation results.
     */
    resetValidation(): Promise<void>;
    /**
     * Returns whether the select has been touched (focused/clicked by user).
     * @returns A boolean indicating whether the select has been touched.
     */
    isTouched(): Promise<boolean>;
    /**
     * Returns whether the select value has been changed by user interaction.
     * @returns A boolean indicating whether the select is dirty.
     */
    isDirty(): Promise<boolean>;
    /**
     * Marks the select as untouched and pristine (not dirty).
     */
    markAsPristine(): Promise<void>;
    /** Validates an element, displays provided message in case value is invalid. */
    setCustomValidity(message: string): Promise<void>;
    /**
     * Validates the textarea without triggering UI and returns a boolean indicating its validity.
     * @returns A boolean indicating whether the textarea is valid.
     */
    checkValidity(): Promise<boolean>;
    /** Check validity and reveal validation state and message */
    reportValidity(): Promise<boolean>;
    /** Set focus on the element */
    setFocus(): Promise<void>;
    /** Remove focus from the element */
    setBlur(): Promise<void>;
    /** Expand options listbox */
    expand(): Promise<void>;
    /** Collapse options listbox */
    collapse(): Promise<void>;
    /**
     * Retrieves the currently focused option within this select component.
     *
     * The focused option is identified by the presence of the `data-focused="true"`
     * attribute on an `r-select-option` element inside the component's host.
     *
     * @returns Promise resolving to the focused `HTMLRSelectOptionElement`, or `null`
     * if no option is currently marked as focused.
     */
    getFocusedOption(): Promise<HTMLRSelectOptionElement>;
    /**
     * Sets focus to the option at the specified index.
     *
     * Retrieves the option element from the internal optionElements collection
     * and delegates focusing logic to `setOptionFocus`.
     *
     * @param index - Zero-based index of the option to focus. If the index is out of bounds
     * or the corresponding option element is unavailable, the method will no-op.
     *
     * @returns A promise that resolves with the result of `setOptionFocus`, typically indicating
     * success or failure of applying focus (implementation dependent).
     */
    setFocusedOption(index: any): Promise<void>;
    private clearOptionsFocus;
    private setComboboxValueOnCollapse;
    private get focusedOptions();
    private toggle;
    private handleSlotChange;
    /**
     * Initial attributes state
     * */
    private initial;
    private messageContainer;
    private get selectedElement();
    private get initiallySelectedElement();
    /** Identify wrapping form element */
    private get parentFormEl();
    /**
     * Determine whether this element should be ignored
     * during Constraint Validation API validation.
     * */
    private get isNoValidate();
    private get optionElements();
    private get optionElementsArray();
    /** Ref element: input that provides value to Constraint Validation API */
    private nativeElement?;
    /** Ref element: block displaying the selected option value */
    private valueElement?;
    /** Ref element: block for combobox container element */
    private comboboxContainerElement?;
    /** Ref element: Listbox, containing options list */
    private listboxElement?;
    /** Ref element: visually hidden element to alert screen reader users that no results found */
    private statusElement?;
    /** Unique id */
    private uniqueId;
    private listboxWidthObserver?;
    private getValidityStateData;
    private validateFormElement;
    private deselectOptions;
    private get isBusy();
    private _renderSelected;
    private setOptionFocus;
    private focusPrevOption;
    private focusNextOption;
    private typeaheadBuffer;
    private typeaheadTimeout;
    private lastTypeaheadIndex;
    /**
     * Return option elements whose label starts with the filter text (case-insensitive).
     */
    private filterOptions;
    /**
     * Return the index (within the provided array) of an option matching the filter.
     * If the filter is multiple iterations of the same letter (e.g. 'aaa'), cycle through
     * first-letter matches starting from startIndex.
     * Returns -1 if no match.
     */
    private getIndexByLetter;
    private handleTypeahead;
    private contributeToFormData;
    private onValueClick;
    private keyboardEventHandlerFactory;
    private onValueKeydown;
    private onComboboxKeydown;
    private onValueBlur;
    private onValueFocus;
    private filterOptionsListByComboboxValue;
    private clearComboboxOptions;
    private onComboboxChange;
    private onComboboxInput;
    private onSubmitForm;
    private onResetForm;
    private connectFormEventListeners;
    private disconnectFormEventListeners;
    private defineHostWidth;
    private _renderNativeOption;
    private notVisible;
    /**
     * Finds first element's parent with not visible overflow.
     * @param element -- parent element
     * @param initEl -- initial(child) element
     */
    private findOverflowParent;
    private get ariaDescribedBy();
    /**
      * Parent with non visible overflow
      */
    get overflowedParent(): HTMLElement;
    /**
     * Available space at the top
     */
    get top(): number;
    /**
     * Available space at the bottom
     */
    get bottom(): number;
    /**
     * Set correct tooltip position.
     * First it checks the available space for a defined position and then sets the new one based on the available space.
     */
    private defineListboxPositionState;
    private initialize;
    private initializeStyleObserver;
    private get hasError();
    private get hasValidationError();
    private get hasMessage();
    private get isInteractive();
    private get hasLeadingSlot();
    private get hasOptionIcon();
    private get isLeadingSlotRendered();
    private get isPlaceholder();
    connectedCallback(): void;
    disconnectedCallback(): void;
    componentWillLoad(): void;
    componentDidLoad(): void;
    private renderSelect;
    private renderCombobox;
    render(): any;
}