novo-elements 11.4.0 → 12.0.0

package/elements/select/index.d.ts

@@ -1,3 +1,248 @@
-export * from './Select';
-export * from './Select.module';
-export * from './Select.extupdatefix.directive';
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnChanges, OnDestroy, ElementRef, ChangeDetectorRef, EventEmitter, QueryList, NgZone, Injector, SimpleChanges } from '@angular/core';
+import * as i3 from '@angular/cdk/a11y';
+import { ActiveDescendantKeyManager, FocusMonitor } from '@angular/cdk/a11y';
+import { SelectionModel } from '@angular/cdk/collections';
+import * as i5 from '@angular/forms';
+import { NgForm, FormGroupDirective, NgControl, ControlValueAccessor } from '@angular/forms';
+import { Subject, Observable } from 'rxjs';
+import { NovoLabelService } from 'novo-elements/services';
+import * as i8 from 'novo-elements/elements/common';
+import { HasOverlayCtor, CanRequireCtor, CanDisableCtor, HasTabIndexCtor, CanUpdateErrorStateCtor, ErrorStateMatcher, NovoOption, NovoOverlayTemplateComponent, NovoOptgroup } from 'novo-elements/elements/common';
+import { NovoFieldControl, NovoFieldElement } from 'novo-elements/elements/field';
+import * as i4 from '@angular/common';
+import * as i6 from 'novo-elements/elements/button';
+import * as i7 from 'novo-elements/elements/divider';
+import * as i9 from 'novo-elements/pipes';
+import * as i10 from 'novo-elements/elements/tooltip';
+import * as i11 from 'novo-elements/elements/icon';
+
+/** Change event object that is emitted when the select value has changed. */
+declare class NovoSelectChange {
+    /** Reference to the select that emitted the change event. */
+    source: NovoSelectElement;
+    /** Current value of the select that emitted the event. */
+    value: any;
+    constructor(
+    /** Reference to the select that emitted the change event. */
+    source: NovoSelectElement, 
+    /** Current value of the select that emitted the event. */
+    value: any);
+}
+declare class NovoSelectBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+}
+declare const NovoSelectMixins: HasOverlayCtor & CanRequireCtor & CanDisableCtor & HasTabIndexCtor & CanUpdateErrorStateCtor & typeof NovoSelectBase;
+declare class NovoSelectElement extends NovoSelectMixins implements OnInit, AfterViewInit, OnChanges, OnDestroy, ControlValueAccessor, NovoFieldControl<any> {
+    elementRef: ElementRef;
+    labels: NovoLabelService;
+    ref: ChangeDetectorRef;
+    private focusMonitor;
+    private ngZone;
+    private injector;
+    private _fieldElement;
+    private _uniqueId;
+    private _stateChanges;
+    private _activeOptionChanges;
+    private _selectedOptionChanges;
+    protected readonly _destroy: Subject<void>;
+    readonly controlType: string;
+    /** @docs-private Implemented as part of NovoFieldControl. */
+    lastKeyValue: string;
+    /** @docs-private Implemented as part of NovoFieldControl.*/
+    lastCaretPosition: number | null;
+    _selectionModel: SelectionModel<NovoOption>;
+    /** The aria-labelledby attribute */
+    _ariaLabelledBy: string;
+    /** The aria-describedby attribute on the chip list for improved a11y. */
+    _ariaDescribedby: string;
+    /** User defined tab index. */
+    _userTabIndex: number | null;
+    /** The FocusKeyManager which handles focus. */
+    _keyManager: ActiveDescendantKeyManager<NovoOption>;
+    /**
+     * The display string for the current value, kept from when the associated <novo-option> has stopped rendering
+     * due to filtration
+     */
+    private _lingeringDisplayValue;
+    private _legacyOption;
+    id: string;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    headerConfig: any;
+    position: string;
+    overlayWidth: number;
+    overlayHeight: number;
+    displayIcon: string;
+    onSelect: EventEmitter<any>;
+    /** Event emitted when the selected value has been changed by the user. */
+    readonly selectionChange: EventEmitter<NovoSelectChange>;
+    /** Event that emits whenever the raw value of the select changes.*/
+    readonly valueChange: EventEmitter<any>;
+    /** Event emitted when the select panel has been toggled. */
+    readonly openedChange: EventEmitter<boolean>;
+    /** Event emitted when the select has been opened. */
+    readonly _openedStream: Observable<void>;
+    /** Event emitted when the select has been closed. */
+    readonly _closedStream: Observable<void>;
+    /** Function that maps an option's control value to its display value in the trigger. */
+    displayWith: ((value: any) => string) | null;
+    /** * Function to compare the option values with the selected values. */
+    compareWith: (o1: any, o2: any) => boolean;
+    header: any;
+    createdItem: any;
+    model: any;
+    onModelChange: Function;
+    onModelTouched: Function;
+    filterTerm: string;
+    filterTermTimeout: any;
+    filteredOptions: any;
+    disabled: boolean;
+    /** Element for the panel containing the autocomplete options. */
+    overlay: NovoOverlayTemplateComponent;
+    optionGroups: QueryList<NovoOptgroup>;
+    contentOptions: QueryList<NovoOption>;
+    viewOptions: QueryList<NovoOption>;
+    viewOptionsSignal: i0.WritableSignal<NovoOption[]>;
+    contentOptionsSignal: i0.WritableSignal<NovoOption[]>;
+    hideLegacyOptionsForSearch: i0.WritableSignal<boolean>;
+    hideLegacyOptions: i0.InputSignalWithTransform<boolean, unknown>;
+    private displayLegacyOptions;
+    panel: ElementRef;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get value(): any;
+    set value(newValue: any);
+    private _value;
+    /** Whether the user should be allowed to select multiple options. */
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    private _multiple;
+    /** Array of options to display in the select dropdown */
+    set options(options: Array<any>);
+    get options(): Array<any>;
+    private _options;
+    /** Whether the select is focused. */
+    get focused(): boolean;
+    private _focused;
+    /** Implemented as part of NovoFieldControl. */
+    get empty(): boolean;
+    /** The currently selected option. */
+    get selected(): NovoOption | NovoOption[];
+    /** The value displayed in the trigger. */
+    get displayValue(): string;
+    constructor(elementRef: ElementRef, labels: NovoLabelService, ref: ChangeDetectorRef, focusMonitor: FocusMonitor, ngZone: NgZone, injector: Injector, defaultErrorStateMatcher: ErrorStateMatcher, ngControl: NgControl, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _fieldElement: NovoFieldElement);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick(): boolean;
+    openPanel(): void;
+    private _initializeSelection;
+    /**
+     * Sets the selected option based on a value. If no option can be
+     * found with the designated value, the select trigger is cleared.
+     */
+    private _setSelectionByValue;
+    /**
+     * Finds and selects and option based on its value.
+     * @returns Option that has the corresponding value.
+     */
+    private _selectValue;
+    select(option: any, i: any, fireEvents?: boolean): void;
+    clear(): void;
+    /**
+     * If the item is not disabled, this method closes the panel, and if a value is specified,
+     * also sets the associated control to that value. It will also mark the control as dirty
+     * if this interaction stemmed from the user.
+     */
+    handleSelection(option: NovoOption, isUserInput?: boolean): void;
+    private _getDisplayValue;
+    /**
+     * Clear any previous selected option and emit a selection change event for this option
+     */
+    private _clearPreviousSelectedOption;
+    private _watchSelectionEvents;
+    /** Handles all keydown events on the select. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Handles keyboard events while the select is closed. */
+    private _handleClosedKeydown;
+    /** Handles keyboard events when the selected is open. */
+    private _handleOpenKeydown;
+    writeValue(value: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(disabled: boolean): void;
+    /** Implemented as part of NovoFieldControl. */
+    setDescribedByIds(ids: string[]): void;
+    /** Implemented as part of NovoFieldControl. */
+    onContainerClick(event: MouseEvent): void;
+    /**
+     * Focuses the first non-disabled chip in this chip list, or the associated input when there
+     * are no eligible chips.
+     */
+    focus(options?: FocusOptions): void;
+    protected _getOptions(): NovoOption[];
+    protected _optionsComputed: i0.Signal<NovoOption[]>;
+    /** Sorts the selected values in the selected based on their order in the panel. */
+    private _sortValues;
+    /** Emits change event to set the model value. */
+    private _propagateChanges;
+    protected _makeChangeEvent(value: any): NovoSelectChange;
+    /** Scrolls the active option into view. */
+    protected _scrollOptionIntoView(index: number): void;
+    /** Sets up a key manager to listen to keyboard events on the overlay panel. */
+    private _initKeyManager;
+    /**
+     * Highlights the selected item. If no option is selected, it will highlight
+     * the first item instead.
+     */
+    private _highlightCorrectOption;
+    /** Calculates the height of the select's options. */
+    private _getItemHeight;
+    private _initLegacyOptions;
+    /**
+     * TODO: Deprecate all header methods
+     */
+    toggleHeader(event: any, forceValue?: boolean): void;
+    /**
+     * @deprecated use highlight pipe
+     */
+    highlight(match: any, query: any): any;
+    escapeRegexp(queryToEscape: any): any;
+    saveHeader(): void;
+    /** Determines the `aria-activedescendant` to be set on the host. */
+    _getAriaActiveDescendant(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSelectElement, [null, null, null, null, null, null, null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoSelectElement, "novo-select", never, { "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "headerConfig": { "alias": "headerConfig"; "required": false; }; "position": { "alias": "position"; "required": false; }; "overlayWidth": { "alias": "overlayWidth"; "required": false; }; "overlayHeight": { "alias": "overlayHeight"; "required": false; }; "displayIcon": { "alias": "displayIcon"; "required": false; }; "displayWith": { "alias": "displayWith"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "hideLegacyOptions": { "alias": "hideLegacyOptions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "onSelect": "onSelect"; "selectionChange": "selectionChange"; "valueChange": "valueChange"; "openedChange": "openedChange"; "_openedStream": "opened"; "_closedStream": "closed"; }, ["optionGroups", "contentOptions"], ["*"], false, never>;
+    static ngAcceptInputType_readonly: unknown;
+}
+
+/**
+ * Fixes a <novo-select> element so that if its value is updated externally, the checkboxes in the dropdown selector
+ * update accordingly. Because this is a functionality change to a core control, this fix is provided as a directive
+ * to only be used if needed.
+ */
+declare class NovoSelectExtUpdateFix implements OnInit {
+    control: NgControl;
+    selectElement: NovoSelectElement;
+    ngOnInit(): void;
+    afterExternalUpdate(rawValue: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSelectExtUpdateFix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoSelectExtUpdateFix, "novo-select[extupdatefix]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NovoSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoSelectModule, [typeof NovoSelectElement, typeof NovoSelectExtUpdateFix], [typeof i3.A11yModule, typeof i4.CommonModule, typeof i5.FormsModule, typeof i6.NovoButtonModule, typeof i7.NovoDividerModule, typeof i8.NovoOptionModule, typeof i8.NovoOverlayModule, typeof i9.NovoPipesModule, typeof i10.NovoTooltipModule, typeof i11.NovoIconModule], [typeof NovoSelectElement, typeof NovoSelectExtUpdateFix]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoSelectModule>;
+}
+
+export { NovoSelectChange, NovoSelectElement, NovoSelectExtUpdateFix, NovoSelectModule };

package/elements/select-search/index.d.ts

@@ -1,3 +1,268 @@
-export * from './select-search-clear.directive';
-export * from './select-search.component';
-export * from './select-search.module';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ChangeDetectorRef, EventEmitter, ElementRef, QueryList } from '@angular/core';
+import { LiveAnnouncer } from '@angular/cdk/a11y';
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import * as i4 from '@angular/forms';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i7 from 'novo-elements/elements/common';
+import { NovoOption } from 'novo-elements/elements/common';
+import * as i11 from 'novo-elements/elements/field';
+import { NovoFieldElement } from 'novo-elements/elements/field';
+import { NovoSelectElement } from 'novo-elements/elements/select';
+import * as i3 from '@angular/common';
+import * as i5 from 'novo-elements/elements/checkbox';
+import * as i6 from 'novo-elements/elements/button';
+import * as i8 from 'novo-elements/elements/icon';
+import * as i9 from 'novo-elements/elements/loading';
+import * as i10 from 'novo-elements/elements/tooltip';
+
+/**
+ * Directive for providing a custom clear-icon.
+ * e.g.
+ * <novo-select-search [formControl]="bankFilterCtrl">
+ *   <novo-icon novoSelectSearchClear>x</novo-icon>
+ * </novo-select-search>
+ */
+declare class NovoSelectSearchClearDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSelectSearchClearDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoSelectSearchClearDirective, "[novoSelectSearchClear]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Component providing an input field for searching NovoSelectElement options.
+ *
+ * Example usage:
+ *
+ * interface Bank {
+ *  id: string;
+ *  name: string;
+ * }
+ *
+ * @Component({
+ *   selector: 'my-app-data-selection',
+ *   template: `
+ *     <novo-form-field>
+ *       <novo-select [formControl]="bankCtrl" placeholder="Bank">
+ *         <novo-option>
+ *           <ngx-novo-select-search [formControl]="bankFilterCtrl"></ngx-novo-select-search>
+ *         </novo-option>
+ *         <novo-option *ngFor="let bank of filteredBanks | async" [value]="bank.id">
+ *           {{bank.name}}
+ *         </novo-option>
+ *       </novo-select>
+ *     </novo-form-field>
+ *   `
+ * })
+ * export class DataSelectionComponent implements OnInit, OnDestroy {
+ *
+ *   // control for the selected bank
+ *   public bankCtrl: FormControl = new FormControl();
+ *   // control for the NovoSelectElement filter keyword
+ *   public bankFilterCtrl: FormControl = new FormControl();
+ *
+ *   // list of banks
+ *   private banks: Bank[] = [{name: 'Bank A', id: 'A'}, {name: 'Bank B', id: 'B'}, {name: 'Bank C', id: 'C'}];
+ *   // list of banks filtered by search keyword
+ *   public filteredBanks: ReplaySubject<Bank[]> = new ReplaySubject<Bank[]>(1);
+ *
+ *   // Subject that emits when the component has been destroyed.
+ *   private _onDestroy = new Subject<void>();
+ *
+ *
+ *   ngOnInit() {
+ *     // load the initial bank list
+ *     this.filteredBanks.next(this.banks.slice());
+ *     // listen for search field value changes
+ *     this.bankFilterCtrl.valueChanges
+ *       .pipe(takeUntil(this._onDestroy))
+ *       .subscribe(() => {
+ *         this.filterBanks();
+ *       });
+ *   }
+ *
+ *   ngOnDestroy() {
+ *     this._onDestroy.next();
+ *     this._onDestroy.complete();
+ *   }
+ *
+ *   private filterBanks() {
+ *     if (!this.banks) {
+ *       return;
+ *     }
+ *
+ *     // get the search keyword
+ *     let search = this.bankFilterCtrl.value;
+ *     if (!search) {
+ *       this.filteredBanks.next(this.banks.slice());
+ *       return;
+ *     } else {
+ *       search = search.toLowerCase();
+ *     }
+ *
+ *     // filter the banks
+ *     this.filteredBanks.next(
+ *       this.banks.filter(bank => bank.name.toLowerCase().indexOf(search) > -1)
+ *     );
+ *   }
+ * }
+ */
+declare class NovoSelectSearchComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    novoSelect: NovoSelectElement;
+    changeDetectorRef: ChangeDetectorRef;
+    private _viewportRuler;
+    novoOption: NovoOption;
+    private liveAnnouncer;
+    matFormField: NovoFieldElement;
+    name: string;
+    /** Label of the search placeholder */
+    placeholderLabel: string;
+    /** Type of the search input field */
+    type: string;
+    /** Label to be shown when no entries are found. Set to null if no message should be shown. */
+    noEntriesFoundLabel: string;
+    /**
+     *  Text that is appended to the currently active item label announced by screen readers,
+     *  informing the user of the current index, value and total options.
+     *  eg: Bank R (Germany) 1 of 6
+     */
+    indexAndLengthScreenReaderText: string;
+    /**
+     * Whether or not the search field should be cleared after the dropdown menu is closed.
+     * Useful for server-side filtering.
+     */
+    clearSearchInput: boolean;
+    /** Whether to show the search-in-progress indicator */
+    searching: boolean;
+    /** Disables initial focusing of the input field */
+    disableInitialFocus: boolean;
+    /** Enable clear input on escape pressed */
+    enableClearOnEscapePressed: boolean;
+    /** Allow user to uncheck a value while filtering. */
+    allowDeselectDuringFilter: boolean;
+    /**
+     * Prevents home / end key being propagated to novo-select,
+     * allowing to move the cursor within the search input instead of navigating the options
+     */
+    preventHomeEndKeyPropagation: boolean;
+    /** Disables scrolling to active options when option list changes. Useful for server-side search */
+    disableScrollToActiveOnOptionsChanged: boolean;
+    /** Adds 508 screen reader support for search box */
+    ariaLabel: string;
+    /** Whether to show Select All Checkbox (for novo-select[multi=true]) */
+    showToggleAllCheckbox: boolean;
+    /** select all checkbox checked state */
+    toggleAllCheckboxChecked: boolean;
+    /** select all checkbox indeterminate state */
+    toggleAllCheckboxIndeterminate: boolean;
+    /** Display a message in a tooltip on the toggle-all checkbox */
+    toggleAllCheckboxTooltipMessage: string;
+    /** Define the position of the tooltip on the toggle-all checkbox. */
+    toogleAllCheckboxTooltipPosition: 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+    /** Show/Hide the search clear button of the search input */
+    hideClearSearchButton: boolean;
+    /**
+     * Always restore selected options on selectionChange for mode multi (e.g. for lazy loading/infinity scrolling).
+     * Defaults to false, so selected options are only restored while filtering is active.
+     */
+    alwaysRestoreSelectedOptionsMulti: boolean;
+    /** Output emitter to send to parent component with the toggle all boolean */
+    toggleAll: EventEmitter<boolean>;
+    /** Reference to the search input field */
+    searchSelectInput: ElementRef;
+    /** Reference to the search input field */
+    innerSelectSearch: ElementRef;
+    /** Reference to custom search input clear icon */
+    clearIcon: NovoSelectSearchClearDirective;
+    get isInsideNovoOption(): boolean;
+    /** Current search value */
+    get value(): string;
+    private _lastExternalInputValue;
+    onTouched: Function;
+    _formControl: FormControl;
+    /** Reference to the NovoSelectElement options */
+    set _options(_options: QueryList<NovoOption>);
+    get _options(): QueryList<NovoOption>;
+    _options$: BehaviorSubject<QueryList<NovoOption>>;
+    private _filterFinishedRerender;
+    private optionsList$;
+    private optionsLength$;
+    /** Previously selected values when using <novo-select [multiple]="true">*/
+    private previousSelectedValues;
+    /** whether to show the no entries found message */
+    _showNoEntriesFound$: Observable<boolean>;
+    /** Subject that emits when the component has been destroyed. */
+    private _onDestroy;
+    constructor(novoSelect: NovoSelectElement, changeDetectorRef: ChangeDetectorRef, _viewportRuler: ViewportRuler, novoOption: NovoOption, liveAnnouncer: LiveAnnouncer, matFormField?: NovoFieldElement);
+    ngOnInit(): void;
+    _emitSelectAllBooleanToParent(state: boolean): void;
+    ngOnDestroy(): void;
+    _isToggleAllCheckboxVisible(): boolean;
+    /**
+     * Handles the key down event with NovoSelectElement.
+     * Allows e.g. selecting with enter key, navigation with arrow keys, etc.
+     * @param event
+     */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Handles the key up event with NovoSelectElement.
+     * Allows e.g. the announcing of the currently activeDescendant by screen readers.
+     */
+    _handleKeyup(event: KeyboardEvent): void;
+    /**
+     * Calculate the index of the current option, taking the offset to length into account.
+     * examples:
+     *    Case 1 [Search, 1, 2, 3] will have offset of 1, due to search and will read index of total.
+     *    Case 2 [1, 2, 3] will have offset of 0 and will read index +1 of total.
+     */
+    getAriaIndex(optionIndex: number): number;
+    /**
+     * Calculate the length of the options, taking the offset to length into account.
+     * examples:
+     *    Case 1 [Search, 1, 2, 3] will have length of options.length -1, due to search.
+     *    Case 2 [1, 2, 3] will have length of options.length.
+     */
+    getAriaLength(): number;
+    writeValue(value: string): void;
+    onBlur(): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: Function): void;
+    /**
+     * Focuses the search input field
+     */
+    _focus(): void;
+    /**
+     * Resets the current search value
+     * @param focus whether to focus after resetting
+     */
+    _reset(focus?: boolean): void;
+    /**
+     * Initializes handling <novo-select [multiple]="true">
+     * Note: to improve this code, novo-select should be extended to allow disabling resetting the selection while filtering.
+     */
+    private initMultipleHandling;
+    /**
+     * Scrolls the currently active option into the view if it is not yet visible.
+     */
+    private adjustScrollTopToFitActiveOptionIntoView;
+    /**
+     *  Set the width of the innerSelectSearch to fit even custom scrollbars
+     *  And support all Operation Systems
+     */
+    updateInputWidth(): void;
+    private getNovoOptionHeight;
+    /**
+     * Determine the offset to length that can be caused by the optional novoOption used as a search input.
+     */
+    private getOptionsLengthOffset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSelectSearchComponent, [null, null, null, { optional: true; }, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoSelectSearchComponent, "novo-select-search", never, { "name": { "alias": "name"; "required": false; }; "placeholderLabel": { "alias": "placeholderLabel"; "required": false; }; "type": { "alias": "type"; "required": false; }; "noEntriesFoundLabel": { "alias": "noEntriesFoundLabel"; "required": false; }; "indexAndLengthScreenReaderText": { "alias": "indexAndLengthScreenReaderText"; "required": false; }; "clearSearchInput": { "alias": "clearSearchInput"; "required": false; }; "searching": { "alias": "searching"; "required": false; }; "disableInitialFocus": { "alias": "disableInitialFocus"; "required": false; }; "enableClearOnEscapePressed": { "alias": "enableClearOnEscapePressed"; "required": false; }; "allowDeselectDuringFilter": { "alias": "allowDeselectDuringFilter"; "required": false; }; "preventHomeEndKeyPropagation": { "alias": "preventHomeEndKeyPropagation"; "required": false; }; "disableScrollToActiveOnOptionsChanged": { "alias": "disableScrollToActiveOnOptionsChanged"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "showToggleAllCheckbox": { "alias": "showToggleAllCheckbox"; "required": false; }; "toggleAllCheckboxChecked": { "alias": "toggleAllCheckboxChecked"; "required": false; }; "toggleAllCheckboxIndeterminate": { "alias": "toggleAllCheckboxIndeterminate"; "required": false; }; "toggleAllCheckboxTooltipMessage": { "alias": "toggleAllCheckboxTooltipMessage"; "required": false; }; "toogleAllCheckboxTooltipPosition": { "alias": "toogleAllCheckboxTooltipPosition"; "required": false; }; "hideClearSearchButton": { "alias": "hideClearSearchButton"; "required": false; }; "alwaysRestoreSelectedOptionsMulti": { "alias": "alwaysRestoreSelectedOptionsMulti"; "required": false; }; }, { "toggleAll": "toggleAll"; }, ["clearIcon"], ["[novoSelectSearchClear]", ".novo-select-search-custom-header-content"], false, never>;
+}
+
+declare class NovoSelectSearchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoSelectSearchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoSelectSearchModule, [typeof NovoSelectSearchComponent, typeof NovoSelectSearchClearDirective], [typeof i3.CommonModule, typeof i4.ReactiveFormsModule, typeof i5.NovoCheckboxModule, typeof i6.NovoButtonModule, typeof i7.NovoCommonModule, typeof i8.NovoIconModule, typeof i9.NovoLoadingModule, typeof i10.NovoTooltipModule, typeof i11.NovoFieldModule], [typeof NovoSelectSearchComponent, typeof NovoSelectSearchClearDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoSelectSearchModule>;
+}
+
+export { NovoSelectSearchClearDirective, NovoSelectSearchComponent, NovoSelectSearchModule };