import * as _angular_core from '@angular/core';
import { Signal, TemplateRef, OnDestroy, InputSignal, OnInit, ElementRef } from '@angular/core';
import { SiFormItemControl } from '@siemens/element-ng/form';
import { TranslatableString } from '@siemens/element-translate-ng/translate';
import { ControlValueAccessor } from '@angular/forms';
import { Observable } from 'rxjs';
import * as _siemens_element_ng_select from '@siemens/element-ng/select';
import { ConfigurableFocusTrapFactory, ConfigurableFocusTrap } from '@angular/cdk/a11y';

/**
 * Selection strategy base class.
 */
declare abstract class SiSelectSelectionStrategy<T, IV = T | T[]> implements ControlValueAccessor {
    /**
     * Whether the select input is disabled.
     *
     * @defaultValue false
     */
    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * The selected value(s).
     */
    set value(value: IV | undefined);
    /** Emitted when the selection is changed */
    readonly valueChange: _angular_core.OutputEmitterRef<IV>;
    /**
     * Whether the select control allows to select multiple values.
     * @internal
     */
    abstract readonly allowMultiple: boolean;
    /**
     * Provides the internal value always as an array
     * @internal
     */
    readonly arrayValue: Signal<readonly T[]>;
    /**
     * Registered form callback which shall be called on blur.
     * @internal
     */
    onTouched: () => void;
    /** @internal */
    readonly disabled: Signal<boolean>;
    protected onChange: (_: any) => void;
    private readonly disabledNgControl;
    private readonly selectOptions;
    registerOnTouched(fn: any): void;
    registerOnChange(fn: any): void;
    /**
     * CDK Listbox value changed handler.
     * @internal
     */
    updateFromUser(values: T[]): void;
    setDisabledState(isDisabled: boolean): void;
    writeValue(obj: any): void;
    protected abstract toArrayValue(value: IV | undefined): readonly T[];
    protected abstract fromArrayValue(value: readonly T[]): IV;
    private updateFromInput;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectSelectionStrategy<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectSelectionStrategy<any, any>, never, never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

/**
 * Copyright (c) Siemens 2016 - 2026
 * SPDX-License-Identifier: MIT
 */

/** A select option group */
interface SelectGroup<T> {
    /** Defines this to be a group. */
    type: 'group';
    /** An optional key to identify this group in a custom template. */
    key?: string;
    /** A label to be shown as header for this group. Is optional if a custom template is provided. */
    label?: TranslatableString;
    /** All options that are part of this group. */
    options: SelectOption<T>[];
}
/** A select option */
interface SelectOption<T> {
    /** Defines this to be an option. */
    type: 'option';
    /**
     * The value if this option.
     * It will be used for formControls and the value property of this `si-select`.
     * The value will internally be checked on equality by using `===`.
     * So an app should either use `string` or ensure that same values are referentially equal.
     */
    value: T;
    /** Whether this option is disabled. */
    disabled?: boolean;
    /** An optional icon. */
    icon?: string;
    /** The color of an icon. */
    iconColor?: string;
    /** An optional stacked icon. */
    stackedIcon?: string;
    /** The color of a stacked icon. */
    stackedIconColor?: string;
    /**
     * A label to be shown for this option.
     * Is optional if a custom template is provided or if the value should directly be rendered.
     */
    label?: TranslatableString;
    /**
     * Used for typeahead functionality when filtering is disabled.
     * If provided, this will be used, otherwise the innerText of the rendered element.
     */
    typeaheadLabel?: TranslatableString;
}
/** Alias for {@link SelectOption} or {@link SelectGroup} */
type SelectItem<T> = SelectGroup<T> | SelectOption<T>;

declare class SiSelectComponent<T> implements SiFormItemControl {
    private static idCounter;
    /**
     * Unique identifier.
     *
     * @defaultValue
     * ```
     * `__si-select-${SiSelectComponent.idCounter++}`
     * ```
     */
    readonly id: _angular_core.InputSignal<string>;
    /**
     * Aria label of the select.
     *
     * @defaultValue null
     */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    /**
     * Aria labelledby of the select.
     * @defaultValue undefined
     */
    readonly labelledbyInput: _angular_core.InputSignal<string | undefined>;
    /**
     * Placeholder for search input field.
     *
     * @defaultValue
     * ```
     * t(() => $localize`:@@SI_SELECT.SEARCH-PLACEHOLDER:Search...`)
     * ```
     */
    readonly filterPlaceholder: _angular_core.InputSignal<TranslatableString>;
    /**
     * Label if no item can be found.
     *
     * @defaultValue
     * ```
     * t(() => $localize`:@@SI_SELECT.NO-RESULTS-FOUND:No results found`)
     * ```
     */
    readonly noResultsFoundLabel: _angular_core.InputSignal<TranslatableString>;
    /** Placeholder text to display when no options are selected. */
    readonly placeholder: _angular_core.InputSignal<TranslatableString | undefined>;
    /**
     * Readonly state. Similar to disabled but with higher contrast *
     *
     * @defaultValue false
     */
    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Emits when the dropdown open state changes. */
    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
    protected readonly optionTemplate: _angular_core.Signal<TemplateRef<{
        $implicit: SelectOption<T>;
    }> | undefined>;
    protected readonly groupTemplate: _angular_core.Signal<TemplateRef<{
        $implicit: SelectGroup<T>;
    }> | undefined>;
    protected readonly actionsTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    private readonly trigger;
    /** @internal */
    readonly labelledby: _angular_core.Signal<string>;
    /**
     * This ID will be bound to the `aria-describedby` attribute of the select.
     * Use this to reference the element containing the error message(s) for the select.
     * It will be picked by the {@link SiFormItemComponent} if the select is used inside a form item.
     *
     * @defaultValue
     * ```
     * `${this.id()}-errormessage`
     * ```
     */
    readonly errormessageId: _angular_core.InputSignal<string>;
    protected rows: readonly SelectItem<T>[];
    protected overlayWidth: number;
    protected readonly selectionStrategy: SiSelectSelectionStrategy<any, any>;
    private backdropClicked;
    /**
     * Enables the filter input
     * @defaultValue false
     * @defaultref {@link SiSelectComponent#_hasFilter}
     */
    readonly hasFilter: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Opens the `si-select`. */
    open(): void;
    /** Closes the `si-select`. */
    close(): void;
    protected backdropClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiSelectComponent<any>, "si-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "labelledbyInput": { "alias": "labelledby"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "noResultsFoundLabel": { "alias": "noResultsFoundLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "errormessageId": { "alias": "errormessageId"; "required": false; "isSignal": true; }; "hasFilter": { "alias": "hasFilter"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, ["optionTemplate", "groupTemplate", "actionsTemplate"], never, true, never>;
}

/**
 * Copyright (c) Siemens 2016 - 2026
 * SPDX-License-Identifier: MIT
 */

/**
 * An interface to define a lazy option source for the {@link SiSelectComponent}.
 *
 * @typeParam TValue - is the type of the value in {@link SiSelectComponent}, so the value of the associated formControl, ngModel or value input.
 */
interface SelectOptionSource<TValue> {
    /**
     * Get options for the provided values.
     * This is basically a resolver function, that resolves values to options.
     *
     * @param values - values that should be resolved to an option.
     */
    getOptionsForValues(values: TValue[]): Observable<SelectOption<TValue>[]>;
    /**
     * Get all available options.
     * If provided, this will be called when no filter value is provided.
     * Otherwise, si-select will only show the selected values.
  
     * This function must be implemented if this source is used on a select without a filter.
     */
    getAllOptions?(): Observable<SelectItem<TValue>[]>;
    /**
     * Find options for a search value. It will never be called with an empty search value.
     *
     * This function must be implemented if this source is used on a si-select with a filter.
     *
     * @param search - value typed by the user in the search field.
     */
    getOptionsForSearch?(search: string): Observable<SelectItem<TValue>[]>;
    /**
     * This function is used to sort options.
     *
     * It is only called if the si-select was able to find all options without querying the option source.
     */
    compareOptions?(a: SelectOption<TValue>, b: SelectOption<TValue>): number;
    /**
     * Function to check if two values are equal.
     *
     * This function must be implemented if the check on reference equality is not enough.
     * For instance, when using objects as value.
     */
    valuesEqual?(optionA: TValue, optionB: TValue): boolean;
}

/**
 * Copyright (c) Siemens 2016 - 2026
 * SPDX-License-Identifier: MIT
 */

interface SiSelectOptionsStrategy<T> {
    /**
     * List of all rows that should be rendered in a selection list.
     */
    readonly rows: Signal<readonly SelectItem<T>[]>;
    /**
     * List of all options that are currently selected.
     * Must be updated when {@link onValueChange} is called.
     */
    readonly selectedRows: Signal<readonly SelectOption<T>[]>;
    /**
     * Indicate loading state of the options.
     */
    readonly loading?: Signal<boolean>;
    /**
     * Is always called when the value changes.
     * The implementation must update {@link selectedRows} when called.
     *
     * @param value - currently selected value of the related si-select.
     */
    onValueChange(value: readonly T[]): void;
    /**
     * This function is called when a user enters a filter query.
     * It is expected that an implementation will update the `rows`
     * based on the query.
     *
     * @param filterInput - Unprocessed input by user in the filterInput field
     */
    onFilter?(filterInput?: string): void;
}

declare class SiSelectLazyOptionsDirective<T> implements SiSelectOptionsStrategy<T>, OnDestroy {
    /**
     * {@inheritDoc SiSelectOptionsStrategy#loading}
     * @defaultValue false
     */
    readonly loading: _angular_core.WritableSignal<boolean>;
    /**
     * {@inheritDoc SiSelectOptionsStrategy#rows}
     * @defaultValue []
     */
    readonly rows: _angular_core.WritableSignal<SelectItem<T>[]>;
    /**
     * {@inheritDoc SiSelectOptionsStrategy#selectedRows}
     * @defaultValue []
     */
    readonly selectedRows: _angular_core.WritableSignal<SelectOption<T>[]>;
    readonly optionSource: _angular_core.InputSignal<SelectOptionSource<T>>;
    private valueChange;
    private filterChange;
    constructor();
    ngOnDestroy(): void;
    /** {@inheritDoc SiSelectOptionsStrategy.onValueChange} */
    onValueChange(value: T[]): void;
    /** {@inheritDoc SiSelectOptionsStrategy.onFilter} */
    onFilter(filterInput?: string): void;
    private valueEqual;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectLazyOptionsDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectLazyOptionsDirective<any>, "si-select[optionSource]", never, { "optionSource": { "alias": "optionSource"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Copyright (c) Siemens 2016 - 2026
 * SPDX-License-Identifier: MIT
 */

/**
 * Input options strategy base class, for eagerly fetched options.
 */
declare abstract class SiSelectOptionsStrategyBase<T> implements SiSelectOptionsStrategy<T> {
    /**
     * Function to compare two values on equality which is used to match/filter options.
     */
    abstract optionsEqual: InputSignal<(a: T, b: T) => boolean>;
    /**
     * All group and option items in the dropdown.
     *
     * @defaultValue []
     */
    abstract readonly allRows: Signal<(SelectItem<T> | SelectOption<T>)[]>;
    private readonly value;
    private readonly filterValue;
    /**
     * Rows that should be shown.
     *
     * @defaultValue []
     */
    readonly rows: Signal<SelectItem<T>[]>;
    readonly selectedRows: Signal<SelectOption<T>[]>;
    onValueChange(value: T[]): void;
    onFilter(filterValue?: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectOptionsStrategyBase<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectOptionsStrategyBase<any>, never, never, {}, {}, never, never, true, never>;
}

/**
 * This directive allows passing {@link SelectItem} to the {@link SiSelectComponent}.
 *
 * @example
 * ```html
 * <si-select [options]="[{ type: 'option', value: 'one', label: 'One' }, { type: 'option', value: 'two', label: 'Two' }]"></si-select>
 * <si-select [options]="[{ type: 'group', label: 'Group', options [{ type: 'option', value: 1, label: 'One' }, { type: 'option', value: 2, label: 'Two' }] }]"></si-select>
 * ```
 */
declare class SiSelectSimpleOptionsDirective<T = string> extends SiSelectOptionsStrategyBase<T> {
    /** Options to be shown in select dropdown */
    readonly options: _angular_core.InputSignal<SelectItem<T>[] | null | undefined>;
    /**
     * By default, values are check on referential equality. Provide a function to customize the behavior.
     *
     * @defaultValue
     * ```
     * (a: T, b: T): boolean => a === b
     * ```
     */
    readonly optionsEqual: _angular_core.InputSignal<(a: T, b: T) => boolean>;
    readonly allRows: _angular_core.Signal<SelectItem<T>[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectSimpleOptionsDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectSimpleOptionsDirective<any>, "si-select[options]", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionsEqual": { "alias": "optionEqualCheckFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The directive enables the single-select behavior.
 * Otherwise, use the {@link SiSelectMultiValueDirective} directive.
 *
 * @example
 * ```html
 * <si-select [(value)]="selectedValue" [options]="[
 *  { id: 'good', title: 'Good' },
 *  { id: 'average', title: 'Average' },
 *  { id: 'poor', title: 'Poor' }
 * ]"></si-select>
 * ```
 */
declare class SiSelectSingleValueDirective<T> extends SiSelectSelectionStrategy<T, T> {
    /**
     * {@inheritDoc SiSelectSelectionStrategy#allowMultiple}
     * @defaultValue false
     */
    allowMultiple: boolean;
    protected toArrayValue(value: T | undefined): readonly T[];
    protected fromArrayValue([value]: readonly T[]): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectSingleValueDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectSingleValueDirective<any>, "si-select:not([multi])", never, {}, {}, never, never, true, never>;
}

/**
 * The directive enables the multi-select behavior.
 * Otherwise, use the {@link SiSelectSingleValueDirective} directive.
 *
 * @example
 * ```html
 * <si-select multi [(value)]="multiValue" [options]="[
 *  { id: 'good', title: 'Good' },
 *  { id: 'average', title: 'Average' },
 *  { id: 'poor', title: 'Poor' }
 * ]"></si-select>
 * ```
 */
declare class SiSelectMultiValueDirective<T> extends SiSelectSelectionStrategy<T, T[]> {
    /**
     * {@inheritDoc SiSelectSelectionStrategy#allowMultiple}
     * @defaultValue true
     */
    readonly allowMultiple = true;
    protected fromArrayValue(value: T[]): T[];
    protected toArrayValue(value: T[] | undefined): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectMultiValueDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectMultiValueDirective<any>, "si-select[multi]", never, {}, {}, never, never, true, never>;
}

/**
 * The directive allows to template/customize the value option rendering.
 * This requires using the {@link SiSelectSimpleOptionsDirective} to specify options as input.
 *
 * @example
 * ```html
 * <si-select [options]="[{ id: 'good', title: 'Good' }, { id: 'fair', title: 'Fair' }, { id: 'bad', title: 'Bad' }]" >
 *   <ng-template siSelectOptionTemplate let-option>{{ option.value | uppercase }}</ng-template>
 * </si-select>
 * ```
 */
declare class SiSelectOptionTemplateDirective {
    /** @internal */
    static ngTemplateContextGuard<T = any>(directive: SiSelectOptionTemplateDirective, context: unknown): context is {
        $implicit: SelectOption<T>;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectOptionTemplateDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectOptionTemplateDirective, "[siSelectOptionTemplate]", never, {}, {}, never, never, true, never>;
}

/**
 * The directive allows to template/customize the group option rendering.
 * This requires using the {@link SiSelectSimpleOptionsDirective} to specify options as input.
 *
 * @example
 * ```html
 * <si-select [options]="[
 *   { type: 'group', key: 'g1', label: 'Group 1', options: [
 *     { type: 'option', value: 'g1.i1', label: 'Item 1' },
 *     { type: 'option', value: 'g1.i2', label: 'Item 2' }
 *   ]},
 *   { type: 'group', key: 'g2', label: 'Group 2', options: [
 *     { type: 'option', value: 'g2.i1', label: 'Item 1' }
 *   ]}
 * ]">
 *   <ng-template siSelectGroupTemplate let-group>{{ group.key | uppercase }}</ng-template>
 * </si-select>
 * ```
 */
declare class SiSelectGroupTemplateDirective {
    static ngTemplateContextGuard<T = any>(directive: SiSelectGroupTemplateDirective, context: unknown): context is {
        $implicit: SelectGroup<T>;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectGroupTemplateDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectGroupTemplateDirective, "[siSelectGroupTemplate]", never, {}, {}, never, never, true, never>;
}

declare class SiSelectActionDirective {
    private readonly select;
    /**
     * Close the select drop down on click.
     * @defaultValue false
     */
    readonly selectActionAutoClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectActionDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectActionDirective, "[siSelectAction]", ["si-select-action"], { "selectActionAutoClose": { "alias": "selectActionAutoClose"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SiSelectActionsDirective {
    /** @internal */
    static ngTemplateContextGuard(directive: SiSelectActionsDirective, context: unknown): context is {
        searchText?: string;
        visibleOptionsCount?: number;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectActionsDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectActionsDirective, "[siSelectActions]", ["si-select-actions"], {}, {}, never, never, true, never>;
}

declare class SiSelectModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SiSelectModule, never, [typeof SiSelectActionDirective, typeof SiSelectActionsDirective, typeof SiSelectComponent, typeof SiSelectGroupTemplateDirective, typeof SiSelectMultiValueDirective, typeof SiSelectOptionTemplateDirective, typeof SiSelectSimpleOptionsDirective, typeof SiSelectSingleValueDirective], [typeof SiSelectActionDirective, typeof SiSelectActionsDirective, typeof SiSelectComponent, typeof SiSelectGroupTemplateDirective, typeof SiSelectMultiValueDirective, typeof SiSelectOptionTemplateDirective, typeof SiSelectSimpleOptionsDirective, typeof SiSelectSingleValueDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SiSelectModule>;
}

declare abstract class SiSelectListBase<T> implements OnInit, OnDestroy {
    readonly baseId: _angular_core.InputSignal<string>;
    readonly optionTemplate: _angular_core.InputSignal<TemplateRef<{
        $implicit: SelectOption<T>;
    }> | undefined>;
    readonly groupTemplate: _angular_core.InputSignal<TemplateRef<{
        $implicit: SelectGroup<T>;
    }> | undefined>;
    /** @defaultValue null */
    readonly labelledby: _angular_core.InputSignal<string | null>;
    readonly actionsTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    readonly closeOverlay: _angular_core.OutputEmitterRef<void>;
    protected readonly selectionStrategy: SiSelectSelectionStrategy<T, T | T[]>;
    protected readonly selectOptions: SiSelectOptionsStrategy<T>;
    protected readonly focusTrapFactory: ConfigurableFocusTrapFactory;
    protected readonly elementRef: ElementRef<any>;
    protected rows: _angular_core.Signal<readonly _siemens_element_ng_select.SelectItem<T>[]>;
    protected focusTrap: ConfigurableFocusTrap;
    protected multiSelect: boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    protected keydownTab(): void;
    protected closeOverlayAlways(): void;
    protected closeOverlayIfSingle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectListBase<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectListBase<any>, never, never, { "baseId": { "alias": "baseId"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "groupTemplate": { "alias": "groupTemplate"; "required": false; "isSignal": true; }; "labelledby": { "alias": "labelledby"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; }, { "closeOverlay": "closeOverlay"; }, never, never, true, never>;
}

declare class SiSelectListHasFilterComponent<T> extends SiSelectListBase<T> implements OnInit {
    /** Placeholder for search input field. */
    readonly filterPlaceholder: _angular_core.InputSignal<TranslatableString>;
    /** Label if no item can be found. */
    readonly noResultsFoundLabel: _angular_core.InputSignal<TranslatableString>;
    protected readonly filterInput: Signal<ElementRef<HTMLInputElement>>;
    protected readonly initIndex: Signal<number>;
    protected readonly id: Signal<string>;
    protected readonly icons: Record<"elementSearch", string>;
    constructor();
    ngOnInit(): void;
    protected input(): void;
    protected select(newValue: T): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectListHasFilterComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiSelectListHasFilterComponent<any>, "si-select-list-has-filter", never, { "filterPlaceholder": { "alias": "filterPlaceholder"; "required": true; "isSignal": true; }; "noResultsFoundLabel": { "alias": "noResultsFoundLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { SiSelectActionDirective, SiSelectActionsDirective, SiSelectComponent, SiSelectGroupTemplateDirective, SiSelectLazyOptionsDirective, SiSelectListHasFilterComponent, SiSelectModule, SiSelectMultiValueDirective, SiSelectOptionTemplateDirective, SiSelectSimpleOptionsDirective, SiSelectSingleValueDirective };
export type { SelectGroup, SelectItem, SelectOption, SelectOptionSource };
