import * as i0 from '@angular/core';
import { OnChanges, DoCheck, SimpleChanges, OnDestroy, AfterViewInit, OnInit } from '@angular/core';
import { SelectControlValueAccessor, ControlValueAccessor, ɵNgSelectMultipleOption as _NgSelectMultipleOption, SelectMultipleControlValueAccessor, NgSelectOption } from '@angular/forms';
import { BooleanInput } from '@angular/cdk/coercion';

/**
 * @description
 * Control value accessor for single-select dropdowns with EUI styling.
 * Extends Angular's SelectControlValueAccessor to handle placeholder behavior and readonly state synchronization.
 *
 * @usageNotes
 * ### Applied automatically
 * ```html
 * <select euiSelect [formControl]="myControl">
 *   <option euiOption [ngValue]="item" *ngFor="let item of items">{{item.label}}</option>
 * </select>
 * ```
 *
 * ### Notes
 * - Automatically applied when using euiSelect with form directives
 * - Handles object values via ngValue
 * - Manages placeholder styling and selection state
 */
declare class EuiSelectControlValueAccessor extends SelectControlValueAccessor implements ControlValueAccessor, OnChanges, DoCheck {
    placeholder: string;
    private elementRef;
    private renderer;
    private placeholderOption;
    private selectComponent;
    private injector;
    constructor();
    ngDoCheck(): void;
    /**
     * Sets the "value" property on the select element.
     *
     * @nodoc
     */
    writeValue(value: any): void;
    registerOnChange(fn: (value: any) => any): void;
    setDisabledState(isDisabled: boolean): void;
    ngOnChanges(changes: SimpleChanges): void;
    private setPlaceholderClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSelectControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiSelectControlValueAccessor, "select:not([multiple])[formControlName][euiSelect],select:not([multiple])[formControl][euiSelect],select:not([multiple])[ngModel][euiSelect]", never, { "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @description
 * Marks `<option>` as dynamic, so Angular can be notified when options change.
 *
 * @see `EuiSelectMultipleControlValueAccessor`
 *
 * @ngModule ReactiveFormsModule
 * @ngModule FormsModule
 * @publicApi
 */
declare class EuiSelectMultipleOption extends _NgSelectMultipleOption implements OnDestroy {
    id: string;
    /** @internal */
    _value: any;
    private element;
    private renderer;
    private select;
    constructor();
    /**
     * @description
     * Tracks the value bound to the option element. Unlike the value binding,
     * ngValue supports binding to objects.
     */
    set ngValue(value: any);
    /**
     * @description
     * Tracks simple string values bound to the option element.
     * For objects, use the `ngValue` input binding.
     */
    set value(value: any);
    /** @internal */
    _setElementValue(value: string): void;
    /** @internal */
    _setSelected(selected: boolean): void;
    /** @nodoc */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSelectMultipleOption, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiSelectMultipleOption, "option, option[euiOption]", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @description
 * The `ControlValueAccessor` for writing multi-select control values and listening to multi-select
 * control changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and
 * `NgModel` directives.
 *
 * @see `EuiSelectControlValueAccessor`
 *
 * @usageNotes
 *
 * ### Using a multi-select control
 *
 * The follow example shows you how to use a multi-select control with a reactive form.
 *
 * ```ts
 * const countryControl = new FormControl();
 * ```
 *
 * ```
 * <select euiSelect multiple name="countries" [formControl]="countryControl">
 *   <option euiOption *ngFor="let country of countries" [ngValue]="country">
 *     {{ country.name }}
 *   </option>
 * </select>
 * ```
 *
 * ### Customizing option selection
 *
 * To customize the default option comparison algorithm, `<select>` supports `compareWith` input.
 * See the `SelectControlValueAccessor` for usage.
 *
 * @ngModule ReactiveFormsModule
 * @ngModule FormsModule
 * @publicApi
 */
declare class EuiSelectMultipleControlValueAccessor extends SelectMultipleControlValueAccessor implements ControlValueAccessor, DoCheck {
    get isInvalid(): boolean;
    set isInvalid(state: BooleanInput);
    /**
     * The current value.
     *
     * @nodoc
     */
    value: any;
    /** @internal */
    _optionMap: Map<string, EuiSelectMultipleOption>;
    /** @internal */
    _idCounter: number;
    protected _isInvalid: boolean;
    private elementRef;
    private renderer;
    private control;
    private selectComponent;
    private injector;
    constructor();
    ngDoCheck(): void;
    /**
     * Sets the "value" property on one or of more of the select's options.
     *
     * @nodoc
     */
    writeValue(value: any): void;
    /**
     * Registers a function called when the control value changes
     * and writes an array of the selected options.
     *
     * @nodoc
     */
    registerOnChange(fn: (value: any) => any): void;
    registerOnTouched(fn: any): void;
    /** @internal */
    _registerOption(value: EuiSelectMultipleOption): string;
    /** @internal */
    _getOptionId(value: any): string | null;
    /** @internal */
    _getOptionValue(valueString: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSelectMultipleControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiSelectMultipleControlValueAccessor, "select[multiple][formControlName][euiSelect],select[multiple][formControl][euiSelect],select[multiple][ngModel][euiSelect]", never, { "isInvalid": { "alias": "isInvalid"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @description
 * Marks `<option>` as dynamic, so Angular can be notified when options change.
 * Supports object values via ngValue and synchronizes with readonly mode.
 *
 * @usageNotes
 * ### With ngValue for objects
 * ```html
 * <option euiOption [ngValue]="user" [label]="user.name">{{user.name}}</option>
 * ```
 *
 * ### With selected state
 * ```html
 * <option euiOption [selected]="isSelected" [value]="id">Label</option>
 * ```
 *
 * ### Notes
 * - Automatically applied to option elements within euiSelect
 * - Use ngValue for complex object binding
 * - Label property updates option text dynamically
 *
 * @see `EuiSelectControlValueAccessor`
 *
 * @ngModule ReactiveFormsModule
 * @ngModule FormsModule
 * @publicApi
 */
declare class EuiNgSelectOptionDirective extends NgSelectOption implements OnDestroy, OnChanges, AfterViewInit {
    selected: boolean;
    label: string;
    private readonly select;
    private readonly selectNative;
    private readonly selectComponent;
    private element;
    private renderer;
    constructor();
    ngAfterViewInit(): void;
    /**
     * @description
     * Tracks the value bound to the option element. Unlike the value binding,
     * ngValue supports binding to objects.
     */
    set ngValue(value: any);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiNgSelectOptionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiNgSelectOptionDirective, "option:not([eclSelectOption]):not([eclMultiselectOption]), option[euiOption]", never, { "selected": { "alias": "selected"; "required": false; }; "label": { "alias": "label"; "required": false; }; "ngValue": { "alias": "ngValue"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_selected: unknown;
}

/**
 * @description
 * Select field that allows users to choose one value from a list of options.
 * `eui-select` integrates with Angular forms and supports dynamic options, object values (`ngValue`), readonly synchronization, and deterministic option rendering through EUI control value accessors.
 * It is designed to work with native `<select>` / `<option>` semantics while ensuring correct behavior with EUI styling, validation, and form state handling.
 *
 * @usageNotes
 * ### Basic usage
 * ```html
 * <select euiSelect [(ngModel)]="selectedValue">
 *   <option value="1">Option 1</option>
 *   <option value="2">Option 2</option>
 * </select>
 * ```
 *
 * ### With placeholder
 * ```html
 * <select euiSelect placeholder="Select an option" [formControl]="control">
 *   <option *ngFor="let item of items" [value]="item.id">{{item.name}}</option>
 * </select>
 * ```
 *
 * ### Readonly mode
 * ```html
 * <select euiSelect [readonly]="true" [(ngModel)]="value">
 *   <option value="approved">Approved</option>
 * </select>
 * ```
 *
 * ### Accessibility
 * - Use aria-label to provide context for screen readers
 * - Invalid state is automatically applied from form validation
 * - Readonly mode creates accessible text input showing selected value
 * - Native select semantics ensure keyboard navigation works as expected
 *
 * ### Notes
 * - Placeholder appears as first option when no value selected
 * - Readonly mode hides select and displays value in text input
 * - Validation state syncs automatically with Angular forms
 * - Use with `euiOption` directive for enhanced option handling
 */
declare class EuiSelectComponent implements OnChanges, OnInit, DoCheck {
    ariaLabel: string;
    placeholder: string;
    readonly: boolean;
    get isInvalid(): boolean;
    set isInvalid(state: BooleanInput);
    protected _isInvalid: boolean;
    private control;
    private readonlyInput;
    private placeholderOption;
    private renderer;
    private injector;
    private elementRef;
    private viewContainerRef;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngDoCheck(): void;
    onChange(value: any): void;
    syncReadOnlyValue(): void;
    /**
     * set readonly value from selected options presented as comma separated string
     *
     * @param readonlyRef the input element to set the value
     * @private
     */
    private setReadonlyValue;
    /**
     * create readonly element
     *
     * @private
     */
    private createReadonlyElement;
    private setPlaceholderClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EuiSelectComponent, "select[euiSelect]", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_readonly: unknown;
}

declare function _buildValueString(id: string, value: any): string;
declare function _extractId(valueString: string): string;

declare const EUI_SELECT: readonly [typeof EuiSelectComponent, typeof EuiNgSelectOptionDirective, typeof EuiSelectControlValueAccessor, typeof EuiSelectMultipleControlValueAccessor, typeof EuiSelectMultipleOption];

export { EUI_SELECT, EuiNgSelectOptionDirective, EuiSelectComponent, EuiSelectControlValueAccessor, EuiSelectMultipleControlValueAccessor, EuiSelectMultipleOption, _buildValueString, _extractId };
//# sourceMappingURL=eui-components-eui-select.d.ts.map