@malva-ui/core 0.1.12 → 0.1.14

package/types/malva-ui-core-select.d.ts

@@ -0,0 +1,456 @@
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { MlvPopupMobileMode } from '@malva-ui/core/popup';
+import { MlvSignalFormControlBase, MlvFormControl, MlvSelectionService, MlvFormState } from '@malva-ui/core/form-utils';
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import { MlvDensity } from '@malva-ui/cdk/density';
+import { MlvOptionsInput, MlvOptionsSearchFn, MlvSelectOptionTransform, MlvOptionMatcher, MlvOptionsAdapter, MlvSelectOption } from '@malva-ui/core/dropdown';
+export * from '@malva-ui/core/dropdown';
+
+declare class MlvSelectListTemplate extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvSelectListTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvSelectListTemplate, "[mlvSelectListTemplate]", never, {}, {}, never, never, true, never>;
+}
+declare class MlvSelectItemTemplate extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvSelectItemTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvSelectItemTemplate, "[mlvSelectItemTemplate]", never, {}, {}, never, never, true, never>;
+}
+declare class MlvSelectSelectedTemplate extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvSelectSelectedTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvSelectSelectedTemplate, "[mlvSelectSelectedTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Visual/validation state of the select. Mirrors {@link MlvFormState}.
+ */
+type MlvSelectState = MlvFormState;
+/** Native rendering mode for the select control. */
+type MlvSelectNativeMode = boolean | 'auto';
+type MlvSelectNativeInput = MlvSelectNativeMode | '' | 'true' | 'false';
+interface NativeOption<T> {
+    readonly key: string;
+    readonly label: string;
+    readonly value: T;
+    readonly group?: string;
+    readonly disabled?: boolean;
+}
+interface NativeOptionGroup<T> {
+    readonly label: string | null;
+    readonly options: readonly NativeOption<T>[];
+}
+declare class MlvSelect<T> extends MlvSignalFormControlBase<T | T[] | null> implements MlvFormControl {
+    /** The scalar, array, or null selection used by all Angular forms APIs. */
+    readonly value: _angular_core.ModelSignal<T | T[] | null>;
+    /**
+     * Selectable options: a plain array, an observable of arrays, or an
+     * `MlvDataSource` (source-side search + lazy paging). Readonly arrays are
+     * accepted because options are never mutated.
+     */
+    readonly options: _angular_core.InputSignal<MlvOptionsInput<T>>;
+    /**
+     * Remote search used by the searchable dropdown:
+     * `(query) => T[] | Promise<T[]> | Observable<T[]>`. When set it supersedes
+     * {@link options} as the item source; the list is not filtered locally. Bind
+     * `[loading]` yourself for any spinner beyond the source-owned one.
+     */
+    readonly searchFn: _angular_core.InputSignal<MlvOptionsSearchFn<T> | null>;
+    /** Debounce (ms) for remote searches (`MlvDataSource` / {@link searchFn}). Local filtering stays instant. */
+    readonly searchDebounce: _angular_core.InputSignal<number>;
+    /** Enables multi-selection mode. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Renders a transparent native `<select>` over the visual trigger. The
+     * native control is populated from `[options]`; custom item and selected
+     * templates are ignored. `true` always uses the native control, `false`
+     * keeps the custom dropdown, and `'auto'` uses the native control below the
+     * `md` breakpoint. A bare `native` attribute is equivalent to
+     * `native="true"`.
+     */
+    readonly native: _angular_core.InputSignalWithTransform<MlvSelectNativeMode, MlvSelectNativeInput>;
+    /** Custom placeholder override. Falls back to the i18n-provided placeholder. */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly toOption: _angular_core.InputSignal<MlvSelectOptionTransform<T>>;
+    /**
+     * Equality predicate used to match option values against the current
+     * selection and against values written through any forms binding. Defaults
+     * to reference equality. Provide e.g. `(a, b) => a.id === b.id` so a
+     * deserialised object value collapses onto its option instance (label and
+     * check-mark agree, and a value that arrives before its options resolves once
+     * they load).
+     */
+    readonly compareWith: _angular_core.InputSignal<(a: T, b: T) => boolean>;
+    /**
+     * Renders a search field as the first row of the open dropdown. Local sources
+     * (array / observable) are filtered by label; remote sources (`MlvDataSource`
+     * / {@link searchFn}) search server-side through the shared adapter.
+     *
+     * While the searchable dropdown is open the combobox semantics move from the
+     * trigger onto the search input and navigation switches to the WAI-ARIA
+     * activedescendant model (DOM focus stays in the search field). A
+     * non-searchable select is untouched.
+     */
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Placeholder of the in-dropdown search field. Falls back to the i18n default. */
+    readonly searchPlaceholder: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Custom local-filter predicate (fuzzy / secondary-field matching). Threaded
+     * into the shared `filterOptions`, whose results are always ranked
+     * prefix-matches-first. Ignored for remote sources, which own their filtering.
+     */
+    readonly matcher: _angular_core.InputSignal<MlvOptionMatcher<T> | undefined>;
+    /**
+     * Controls whether the dropdown renders as a full-screen mobile sheet.
+     *
+     * Passed straight through to the underlying `mlv-popup`. Defaults to
+     * `'auto'` — the dropdown is full-screen below the `md` breakpoint
+     * (viewport < 768px) and trigger-anchored above it, matching the date/time
+     * pickers. Set to `'off'` to always anchor to the trigger, or `'fullscreen'`
+     * to always render the sheet (e.g. demos). Unlike `mlv-combobox` (whose
+     * search input lives outside the overlay panel), the select trigger is a plain
+     * button and its dropdown is the entire interaction surface, so full-screen
+     * mode composes cleanly.
+     */
+    readonly mobileMode: _angular_core.InputSignal<MlvPopupMobileMode>;
+    /**
+     * Density applied to the dropdown's option list.
+     *
+     * The dropdown panel is portaled to the CDK overlay container, outside the
+     * component's DOM tree, so ancestor density classes cannot cascade into it.
+     * This input is forwarded to the underlying `mlv-popup`, which stamps the
+     * resolved `mlv--{density}` class on the detached panel. When omitted, the
+     * nearest ancestor `MLV_DENSITY_CONTEXT` (e.g. a `form[mlvForm]`) applies,
+     * then the global `MlvDensityService`.
+     */
+    readonly mlvDensity: _angular_core.InputSignal<MlvDensity | undefined>;
+    /**
+     * Optional visible heading rendered in the full-screen sheet's header bar.
+     * When omitted, falls back to the field's `label` (or, when unset, the
+     * resolved placeholder). Only shown while the dropdown is full-screen.
+     */
+    readonly mobileTitle: _angular_core.InputSignal<string | undefined>;
+    /**
+     * @protected Resolved full-screen sheet title: explicit `mobileTitle` input
+     * takes precedence over the field's label, then the resolved placeholder.
+     */
+    protected readonly _resolvedMobileTitle: _angular_core.Signal<string>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvSelectI18n>;
+    /** @private Shared responsive breakpoint state used by native `'auto'` mode. */
+    private readonly _breakpoint;
+    protected readonly _formI18n: _angular_core.Signal<_malva_ui_i18n.MlvFormUtilsI18n>;
+    /** @protected Resolved placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedPlaceholder: _angular_core.Signal<string>;
+    /**
+     * @protected Accessible name forwarded to the dropdown panel's inner
+     * `role="listbox"` (`mlv-dropdown-panel`'s `ariaLabel`). Mirrors the
+     * trigger's own resolution — the visible {@link label} when set (linked
+     * there via `aria-labelledby`), else the explicit {@link ariaLabel} input
+     * (rendered as the trigger's own `aria-label`) — so the listbox shares the
+     * same accessible name as the field it belongs to. `null` when neither is
+     * set, same as an unlabelled trigger.
+     */
+    protected readonly _panelAriaLabel: _angular_core.Signal<string | null>;
+    readonly focused: _angular_core.Signal<boolean>;
+    /**
+     * @private Latches `true` the first time a **remote** source reports
+     * `ready()`, and never flips back. It gates {@link _adapter}'s `eager` flag
+     * off for good.
+     *
+     * Without the latch, a `searchFn` bound to an inline arrow — a fresh
+     * reference on every change detection run — re-arms the adapter's lazy gate
+     * on every pass; while `eager` is still `true` (a committed value the first
+     * response did not contain) each pass would fire another request, whose
+     * result triggers the next pass. The latch bounds that to exactly one eager
+     * load per mount.
+     */
+    private readonly _eagerDone;
+    /**
+     * @protected Shared source adapter — arrays / observables are local, a data
+     * source or a `searchFn` is remote (the source filters and the items render
+     * as-is). Template-facing: the paging bindings (`hasMore` / `loadingMore` /
+     * `loadMore`) read straight off it.
+     *
+     * The `eager` closure reads {@link hasValue} / {@link _allValuesMatched}
+     * lazily, so declaring those below is fine — the adapter's effects run after
+     * construction. A committed value with no resolvable label is what makes a
+     * `searchFn` load without waiting for the first open. The explicit type
+     * annotation breaks the inference cycle that closure creates
+     * (`_adapter` → `eager` → `_allValuesMatched` → `resolvedOptions` → `_adapter`).
+     */
+    protected readonly _adapter: MlvOptionsAdapter<T>;
+    readonly resolvedOptions: _angular_core.Signal<MlvSelectOption<T>[]>;
+    /**
+     * @protected Whether the native select is the active interaction surface.
+     * `'auto'` follows the shared `md` breakpoint and updates when the viewport
+     * changes.
+     */
+    protected readonly _nativeActive: _angular_core.Signal<boolean>;
+    /**
+     * @protected Normalized native option groups. Each option receives an
+     * internal index key so arbitrary `T` values can travel through the native
+     * select without stringifying the public form value.
+     */
+    protected readonly _nativeOptionGroups: _angular_core.Signal<readonly NativeOptionGroup<T>[]>;
+    /** @protected Whether every committed value has a matching option (by `compareWith`). */
+    protected readonly _allValuesMatched: _angular_core.Signal<boolean>;
+    /** @protected First payload arrived and the consumer is not reporting `loading`. */
+    protected readonly _ready: _angular_core.Signal<boolean>;
+    /**
+     * @protected Loading variant: a value is committed but no option resolves its
+     * label yet. The trigger is inert (no open) but stays tabbable, shows a
+     * spinner instead of the chevron and the i18n loading text instead of a raw
+     * value.
+     */
+    protected readonly _awaitingValueLabel: _angular_core.Signal<boolean>;
+    /** @protected Panel spinner row: source-owned loading OR the consumer's `[loading]`. */
+    protected readonly _panelLoading: _angular_core.Signal<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly triggerWidth: _angular_core.WritableSignal<number>;
+    /**
+     * Current text of the in-dropdown search field. Always `''` while the
+     * dropdown is closed — closing resets it (see `_onPopupClosed`).
+     */
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    /**
+     * The options actually rendered in the panel: locally filtered by
+     * {@link searchQuery} while searchable over a local source, the source's
+     * items as-is otherwise (a remote source filters server-side, and a
+     * non-searchable select never filters).
+     */
+    readonly filteredOptions: _angular_core.Signal<MlvSelectOption<T>[]>;
+    /**
+     * @private Shared activedescendant bookkeeping over {@link filteredOptions}
+     * (searchable mode only) — the same engine behind `mlv-combobox` and
+     * `[mlvAutocomplete]`. The count is read lazily, so it always reflects the
+     * live filtered list.
+     */
+    private readonly _activeDescendant;
+    /**
+     * @protected Active option index handed to the panel. Pinned to `-1` while
+     * not searchable so the roving-focus panel never renders an active row.
+     */
+    protected readonly _activeIndex: _angular_core.Signal<number>;
+    /** @protected `aria-activedescendant` target of the search input, or `null`. */
+    protected readonly _activeOptionId: _angular_core.Signal<string | null>;
+    /**
+     * @protected DOM `id` of the in-dropdown search input. Distinct from the
+     * trigger's `id()` so both can coexist, and deterministic so the field can be
+     * focus-targeted by id once the popup has opened.
+     */
+    protected readonly _searchInputId: _angular_core.Signal<string>;
+    /**
+     * @protected Whether the trigger owns the combobox semantics. `false` only
+     * while the searchable dropdown is open — the search input is the live
+     * combobox then, so exactly one `role="combobox"` is ever exposed. The
+     * trigger becomes a plain `role="button"` there rather than losing its role:
+     * a role-less `<div>` may carry no ARIA state at all, whereas a button that
+     * opened a popup legitimately keeps `aria-expanded` / `aria-haspopup` /
+     * `aria-controls`. Only `aria-required` (invalid on `button`) is dropped.
+     */
+    protected readonly _outerIsCombobox: _angular_core.Signal<boolean>;
+    /**
+     * @protected Matched-substring emphasis for the option rows. Only while
+     * searching a **local** source — a remote source's results need not contain
+     * the query at all.
+     */
+    protected readonly _highlightQuery: _angular_core.Signal<string>;
+    /** @protected Resolved search placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedSearchPlaceholder: _angular_core.Signal<string>;
+    /** @private ICU resolver for parameterised i18n strings. */
+    private readonly _resolver;
+    /**
+     * @protected Polite screen-reader announcement of the current result count.
+     * Empty unless the searchable dropdown is open, so no stale count is read out.
+     * Mirrors the visible empty-state copy rendered inside the panel.
+     */
+    protected readonly _resultsAnnouncement: _angular_core.Signal<string>;
+    /** The HTML `id` assigned to the inner listbox element for `aria-controls` linking. */
+    readonly listboxId: _angular_core.Signal<string>;
+    /**
+     * The HTML `id` assigned to the visible `<mlv-label>` element. The trigger
+     * references it via `aria-labelledby` (a `<label for>` cannot name a `<div>`).
+     */
+    readonly labelId: _angular_core.Signal<string>;
+    readonly dropdownPositions: ConnectedPosition[];
+    readonly selectionService: MlvSelectionService<any>;
+    itemTemplate: _angular_core.Signal<MlvSelectItemTemplate | undefined>;
+    selectedTemplate: _angular_core.Signal<MlvSelectSelectedTemplate | undefined>;
+    /** @private Reference to the trigger element, used to restore focus after selection. */
+    private readonly _triggerElement;
+    /** @private Reference to the transparent native select when native mode is active. */
+    private readonly _nativeSelect;
+    /** @private Reference to the rendered dropdown panel component. */
+    private readonly _dropdownPanel;
+    /** @private Raw values last written through a forms binding, pre-normalisation. */
+    private _pendingValues;
+    constructor();
+    get displayValue(): string;
+    /**
+     * Toggles the dropdown. Closing is always allowed — a panel opened before the
+     * control turned inert (a late `[loading]`, a value written under an open
+     * list) must stay dismissable from its own trigger; only opening is gated.
+     */
+    toggleDropdown(): void;
+    setInitialFocus(): void;
+    /**
+     * Focuses the trigger and opens the dropdown. Focus moves even while merely
+     * awaiting a value's label — this is the label's click target, and a click on
+     * a field's label must always land the caret on that field; only the open is
+     * suppressed. A **disabled** field is the exception: it takes neither the
+     * caret nor the open (the trigger's `tabindex="-1"` would still accept
+     * programmatic focus).
+     */
+    openDropdown(): void;
+    /**
+     * @protected Trigger keyboard open. ArrowUp / ArrowDown open the dropdown and
+     * move focus onto the first option (`focusFirst`); Home / End only open it,
+     * leaving the roving focus where the panel puts it. No-op while inert, but the
+     * default is always prevented so a still-resolving trigger never scrolls the
+     * page instead.
+     *
+     * The focus request is roving-mode only: a searchable dropdown hands focus to
+     * its search input instead (`_onPopupOpened`), and pulling it onto an option
+     * would break the activedescendant model.
+     */
+    protected _openFromKey(event: Event, focusFirst: boolean): void;
+    /**
+     * @protected Whether every open / interaction path is suppressed: the control
+     * is disabled, or a committed value's label is still resolving (the trigger
+     * stays tabbable and readable, but must not open a list that cannot yet show
+     * the current selection).
+     */
+    protected _isInert(): boolean;
+    /**
+     * Handles a selection change emitted by the aria listbox panel. The panel
+     * always emits the flat `V[]` array that `@angular/aria`'s `ngListbox`
+     * models; {@link fromAriaValues} collapses it back to the public forms value
+     * shape (`T` for single-select, `T[]` for multi-select, `null` when cleared).
+     *
+     * aria re-emits its value whenever the *rendered* option set changes (an
+     * async load landing while the panel is open, later search filtering) — those
+     * reconciliation emits are ignored via the shared guard, so they can never
+     * wipe the committed value. A genuine multi-select pick re-adds the committed
+     * values aria dropped only because their option is not rendered.
+     */
+    selectOption(values: readonly T[]): void;
+    /**
+     * @private Writes a genuine selection — the single commit path shared by the
+     * panel's `valueChange` and the search field's Enter. Single-select closes the
+     * dropdown and returns focus to the trigger; multi-select stays open so the
+     * next option can be picked.
+     */
+    private _commitSelection;
+    /**
+     * @protected Values of the options currently rendered in the panel (the
+     * reconciliation guard's "visible" set) — the filtered set while searching.
+     */
+    protected _visibleValues(): T[];
+    /**
+     * @protected Search-field input. Local sources narrow {@link filteredOptions}
+     * instantly; remote ones are asked (debounced) instead, because filtering
+     * locally as well would hide server results and empty the list while a newer
+     * query is still in flight.
+     */
+    protected _onSearchInput(event: Event): void;
+    /** @protected ArrowDown — activate the next option (wrap-around). */
+    protected _onSearchArrowDown(event: Event): void;
+    /** @protected ArrowUp — activate the previous option (wrap-around). */
+    protected _onSearchArrowUp(event: Event): void;
+    /** @protected Home — activate the first option. */
+    protected _onSearchHome(event: Event): void;
+    /** @protected End — activate the last option. */
+    protected _onSearchEnd(event: Event): void;
+    /**
+     * @protected Enter — commit the active option (APG "Enter selects active").
+     * No-op when nothing is active. Multi-select toggles the option and resets the
+     * active index so the narrowed list is navigated from the top again.
+     */
+    protected _onSearchEnter(event: Event): void;
+    /** @protected Escape — closes the dropdown (the close resets the query). */
+    protected _onSearchEscape(event: Event): void;
+    /**
+     * @protected Tab / Shift+Tab — closes the dropdown. The default is prevented
+     * because the search field lives in a detached overlay: letting Tab run would
+     * move focus to whatever follows the overlay in the DOM rather than to the
+     * field after the select. `_onPopupClosed` puts focus back on the trigger.
+     */
+    protected _onSearchTab(event: Event): void;
+    /**
+     * @protected Panel `mousedown`. In searchable mode the default is prevented
+     * so pointing at an option (or the scrollbar) cannot blur the search input —
+     * the activedescendant model and the open state both depend on focus staying
+     * there. It must stay a **method**: an inline `searchable() && preventDefault()`
+     * expression evaluates to `false` on the non-searchable path, and Angular
+     * treats a `false` listener return as `preventDefault()`, which would swallow
+     * the default for every select dropdown (breaking roving focus transfer to a
+     * clicked option and text selection).
+     */
+    protected _onPanelMousedown(event: MouseEvent): void;
+    /** @protected Handles a value change from the native select. */
+    protected _onNativeChange(event: Event): void;
+    /** @protected Focuses the active interaction surface when the label is clicked. */
+    protected _onLabelClick(): void;
+    /** @protected Marks the native select as focused for the form wrapper. */
+    protected _onNativeFocus(): void;
+    /** @protected Marks the native select blur as the end of field interaction. */
+    protected _onNativeBlur(): void;
+    /** @protected Whether a normalized option matches one of the committed values. */
+    protected _isNativeOptionSelected(value: T): boolean;
+    /** @private Resolves an internal native option key back to its public option. */
+    private _nativeOptionFromKey;
+    /**
+     * @protected After the popup opens: hand focus to the search field. The input
+     * is stamped inside the overlay (a detached embedded view), so it is not
+     * reachable through this component's view queries — locate it by its
+     * deterministic id, the same pattern `mlv-combobox` / `mlv-day-picker` use.
+     * The lazy first load is triggered by the `isOpen` effect, not here.
+     */
+    protected _onPopupOpened(): void;
+    /**
+     * @protected After the popup closes: restore focus to the trigger and (when
+     * searchable) drop the query, so the next open starts from the full list. A
+     * remote source is re-asked for `''` once, otherwise a blank search field
+     * would sit above a list still filtered by the previous query.
+     */
+    protected _onPopupClosed(): void;
+    setFocused(isFocused?: boolean): void;
+    /** @protected Marks the select touched when its trigger loses focus. */
+    protected _onTriggerBlur(): void;
+    updateTriggerWidth(evt: ResizeObserverEntry[]): void;
+    /** Whether the control holds a clearable value — At least one option selected. */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /**
+     * The select renders its own clear button overlaid in the trigger row,
+     * before the chevron — the wrapper must not render its trailing copy.
+     */
+    readonly ownsClearButton: _angular_core.Signal<boolean>;
+    /**
+     * @protected Whether the inline clear affordance is visible: clearable, a
+     * value present, and the control interactive. Shared by the template's @if
+     * and the trigger's padding-reserve class.
+     *
+     * Deliberately **not** gated on {@link _awaitingValueLabel}: the loading
+     * variant makes every open path inert, so the clear button is the only
+     * escape hatch left when a source never answers. `onClear()` works there —
+     * dropping the value clears `hasValue()`, which ends the variant.
+     */
+    protected readonly _showClear: _angular_core.Signal<boolean>;
+    /** Clears the selection, writes the cleared forms value, and marks touched. */
+    onClear(): void;
+    /**
+     * @private Syncs the selection service (the aria listbox panel's `value`
+     * source) from the values last written through a forms binding. Each pending
+     * value is matched against the current options via {@link compareWith} and
+     * replaced by the option's own instance, so the check-marks and the displayed
+     * label agree — and a value written before its options exist resolves as soon
+     * as they arrive (the caller effect tracks `resolvedOptions()`).
+     */
+    private _applyPendingValues;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvSelect<any>, "mlv-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "searchFn": { "alias": "searchFn"; "required": false; "isSignal": true; }; "searchDebounce": { "alias": "searchDebounce"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "native": { "alias": "native"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "toOption": { "alias": "toOption"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "matcher": { "alias": "matcher"; "required": false; "isSignal": true; }; "mobileMode": { "alias": "mobileMode"; "required": false; "isSignal": true; }; "mlvDensity": { "alias": "mlvDensity"; "required": false; "isSignal": true; }; "mobileTitle": { "alias": "mobileTitle"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["itemTemplate", "selectedTemplate"], never, true, never>;
+}
+
+export { MlvSelect, MlvSelectItemTemplate, MlvSelectListTemplate, MlvSelectSelectedTemplate };
+export type { MlvSelectNativeMode, MlvSelectState };