@malva-ui/core 0.1.13 → 0.1.14

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

@@ -0,0 +1,121 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/aria/accordion';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/**
+ * Vertical accordion container built on the `@angular/aria` `AccordionGroup`
+ * headless pattern. Projects one or more `mlv-accordion-item` children and
+ * coordinates their expand/collapse behaviour, single- vs multi-expand mode,
+ * and roving keyboard navigation (Arrow Up/Down, Home, End) across the item
+ * headers.
+ *
+ * The `@angular/aria` `AccordionGroup` is applied as a host directive so the
+ * `ACCORDION_GROUP` DI token it provides is visible to the triggers rendered
+ * inside each projected `mlv-accordion-item`. Its inputs are re-exposed
+ * verbatim on `<mlv-accordion>` — the aria directive owns the roles, keyboard
+ * event listeners, roving tabindex, and `aria-*` wiring.
+ *
+ * @example Single-expand (default aria behaviour is multi-expand)
+ * ```html
+ * <mlv-accordion [multiExpandable]="false">
+ *   <mlv-accordion-item header="Shipping">…</mlv-accordion-item>
+ *   <mlv-accordion-item header="Returns">…</mlv-accordion-item>
+ * </mlv-accordion>
+ * ```
+ *
+ * @example Programmatic expand/collapse all
+ * ```html
+ * <mlv-accordion #acc [multiExpandable]="true">…</mlv-accordion>
+ * <button (click)="acc.expandAll()">Expand all</button>
+ * <button (click)="acc.collapseAll()">Collapse all</button>
+ * ```
+ */
+declare class MlvAccordion {
+    /**
+     * @private The host `@angular/aria` `AccordionGroup` directive instance,
+     * used to delegate the imperative `expandAll()` / `collapseAll()` calls.
+     */
+    private readonly _group;
+    /**
+     * Expands every accordion item. Only has an effect when `multiExpandable`
+     * is `true`; in single-expand mode the aria pattern keeps at most one panel
+     * open.
+     */
+    expandAll(): void;
+    /** Collapses every accordion item. */
+    collapseAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvAccordion, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvAccordion, "mlv-accordion", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.AccordionGroup; inputs: { "multiExpandable": "multiExpandable"; "disabled": "disabled"; "softDisabled": "softDisabled"; "wrap": "wrap"; }; outputs: {}; }]>;
+}
+
+/**
+ * A single expandable section of a `mlv-accordion`.
+ *
+ * Renders a header button (the `@angular/aria` `AccordionTrigger`) and a
+ * lazily-rendered content region (`AccordionPanel` + `AccordionContent`). The
+ * visual open/close animation is provided by wrapping the panel content in
+ * `mlv-expand`; the aria directives own the `role`, `aria-expanded`,
+ * `aria-controls`/`aria-labelledby` linkage, `inert`, and keyboard handling.
+ *
+ * Panel content is rendered lazily on first expand via aria's `DeferredContent`
+ * and then kept mounted (`preserveContent`) so the `mlv-expand`
+ * grid-row animation is never torn down mid-transition — the collapse hides the
+ * content through `mlv-expand`'s own `@if`, not by unmounting the panel.
+ *
+ * @example
+ * ```html
+ * <mlv-accordion>
+ *   <mlv-accordion-item header="Billing" [(expanded)]="billingOpen">
+ *     <p>Manage your billing details…</p>
+ *   </mlv-accordion-item>
+ * </mlv-accordion>
+ * ```
+ */
+declare class MlvAccordionItem {
+    /**
+     * Plain-text header shown in the trigger button. For rich header content
+     * (icons, badges) project an element marked with the `mlvAccordionHeader`
+     * directive instead.
+     */
+    readonly header: i0.InputSignal<string>;
+    /**
+     * Disables this item: the trigger becomes non-interactive and gets
+     * `aria-disabled="true"`. Whether it stays keyboard-focusable is governed by
+     * the parent `mlv-accordion`'s `softDisabled` input (aria default: focusable).
+     * Supports attribute syntax: `<mlv-accordion-item disabled>`.
+     */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Two-way bindable expanded state of this item. Bind with
+     * `[(expanded)]="mySignal"`, or observe changes with
+     * `(expandedChange)="onToggle($event)"`. Kept in sync with the aria
+     * `AccordionTrigger` expansion model.
+     */
+    readonly expanded: i0.ModelSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvAccordionItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvAccordionItem, "mlv-accordion-item", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["[mlvAccordionHeader]", "*"], true, never>;
+}
+
+/**
+ * Marks projected content as the rich header of a `mlv-accordion-item`.
+ *
+ * Use it when the header needs more than the plain `header` string input
+ * (icons, badges, multi-line markup). When present, it renders inside the
+ * accordion trigger button alongside — or instead of — the `header` text.
+ *
+ * @example
+ * ```html
+ * <mlv-accordion-item>
+ *   <span mlvAccordionHeader>
+ *     <svg lucideFolder [size]="16" /> Documents
+ *   </span>
+ *   <p>Panel content…</p>
+ * </mlv-accordion-item>
+ * ```
+ */
+declare class MlvAccordionHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvAccordionHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvAccordionHeader, "[mlvAccordionHeader]", never, {}, {}, never, never, true, never>;
+}
+
+export { MlvAccordion, MlvAccordionHeader, MlvAccordionItem };

package/types/malva-ui-core-action-bar.d.ts

@@ -0,0 +1,82 @@
+import * as i0 from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/**
+ * Vertical anchor of the action bar. `'bottom'` is the natural companion to
+ * `shape="pill"` + `contrast` for floating selection toolbars that appear when
+ * the user selects rows in a data-table.
+ */
+type MlvActionBarPosition = 'top' | 'bottom';
+/**
+ * Visual shape of the action bar.
+ *
+ * - `'default'` — full-width bar with a flush bottom / top border.
+ * - `'pill'` — content-width floating pill with a fully rounded radius and a
+ *   drop shadow. When paired with `fixed`, the pill auto-centers horizontally.
+ */
+type MlvActionBarShape = 'default' | 'pill';
+declare class MlvActionBar {
+    /**
+     * Applies `position: sticky` so the bar stays pinned while its scroll
+     * container scrolls past it.
+     */
+    readonly sticky: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Applies `position: fixed` so the bar stays pinned to the viewport. When
+     * combined with `shape="pill"`, the bar is auto-centered horizontally.
+     */
+    readonly fixed: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Vertical placement of the bar. Used as the anchor edge when combined with
+     * `fixed` or `sticky`, and as the enter/leave animation direction.
+     * Defaults to `'top'`.
+     */
+    readonly position: i0.InputSignal<MlvActionBarPosition>;
+    /**
+     * Visual shape. See {@link MlvActionBarShape}. Defaults to `'default'`.
+     */
+    readonly shape: i0.InputSignal<MlvActionBarShape>;
+    /**
+     * Lets the bar's content flow onto further lines once it no longer fits on
+     * one, instead of overflowing its container.
+     *
+     * Off by default, so an application navigation bar keeps its single-row
+     * geometry and relies on `[mlvActionBarActions]` to shed controls at narrow
+     * widths. Turn it on for content-heavy bars — for example a workflow toolbar
+     * projected into `mlv-page-dock` — that must stay fully reachable on a
+     * narrow canvas. On a wide viewport nothing wraps and the look is unchanged.
+     */
+    readonly wrap: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Renders the bar on a dark, inverted surface so it stands out from the
+     * surrounding content. On the light theme the bar becomes a distinctive
+     * near-black surface; on the dark theme it flips to a contrasting lighter
+     * surface. Child controls automatically adapt their text / icon color so
+     * they remain readable on the inverted background.
+     */
+    readonly contrast: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvActionBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvActionBar, "[mlvActionBar]", never, { "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "contrast": { "alias": "contrast"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Marks desktop-only action-bar content that is hidden at the medium
+ * breakpoint and below.
+ */
+declare class MlvActionBarActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvActionBarActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvActionBarActions, "[mlvActionBarActions]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MlvActionBarLogo {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvActionBarLogo, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvActionBarLogo, "[mlvActionBarLogo]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MlvActionBarSpacer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvActionBarSpacer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvActionBarSpacer, "[mlvActionBarSpacer]", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { MlvActionBar, MlvActionBarActions, MlvActionBarLogo, MlvActionBarSpacer };
+export type { MlvActionBarPosition, MlvActionBarShape };

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

@@ -0,0 +1,131 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvTone } from '@malva-ui/cdk/utils';
+
+/**
+ * Slot directive for projecting a custom icon into the alert's icon area.
+ *
+ * Place inside an `<ng-template>` inside `<mlv-alert>` to override the
+ * default tone icon with custom content.
+ *
+ * @example
+ * ```html
+ * <mlv-alert tone="info">
+ *   <ng-template mlvAlertIcon>
+ *     <svg lucideInfo [size]="16" />
+ *   </ng-template>
+ *   Your session will expire soon.
+ * </mlv-alert>
+ * ```
+ */
+declare class MlvAlertIcon {
+    /** The template reference for this icon slot. */
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvAlertIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvAlertIcon, "[mlvAlertIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot directive for projecting a custom title into the alert's title area.
+ *
+ * Place inside an `<ng-template>` inside `<mlv-alert>` to provide a structured
+ * title line above the main description content.
+ *
+ * @example
+ * ```html
+ * <mlv-alert tone="warning">
+ *   <ng-template mlvAlertTitle>Storage nearly full</ng-template>
+ *   You have used 90% of your storage quota.
+ * </mlv-alert>
+ * ```
+ */
+declare class MlvAlertTitle {
+    /** The template reference for this title slot. */
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvAlertTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvAlertTitle, "[mlvAlertTitle]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Inline feedback banner component for displaying contextual messages.
+ *
+ * Supports four semantic tones (`info`, `success`, `warning`, `danger`),
+ * optional dismiss button, custom icon slot, and separate title/description
+ * content projection slots.
+ *
+ * @example Basic
+ * ```html
+ * <mlv-alert tone="info">Your profile has been updated.</mlv-alert>
+ * ```
+ *
+ * @example With title
+ * ```html
+ * <mlv-alert tone="warning">
+ *   <ng-template mlvAlertTitle>Storage nearly full</ng-template>
+ *   You have used 90% of your storage quota.
+ * </mlv-alert>
+ * ```
+ *
+ * @example Dismissible
+ * ```html
+ * <mlv-alert tone="success" dismissible (dismissed)="onDismissed()">
+ *   File uploaded successfully.
+ * </mlv-alert>
+ * ```
+ *
+ * @example Custom icon
+ * ```html
+ * <mlv-alert tone="info">
+ *   <ng-template mlvAlertIcon><svg lucideRocket [size]="16" /></ng-template>
+ *   New version available.
+ * </mlv-alert>
+ * ```
+ */
+declare class MlvAlert {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvAlertI18n>;
+    /**
+     * The semantic tone of the alert.
+     * Controls the color scheme and default icon.
+     * Defaults to `'info'`.
+     */
+    readonly tone: _angular_core.InputSignal<MlvTone>;
+    /**
+     * When `true`, renders a dismiss (close) button in the alert.
+     * Clicking it emits `dismissed` and hides the alert.
+     * Supports attribute syntax: `<mlv-alert dismissible>`.
+     */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, renders the alert with a transparent background and a colored border.
+     * The text and border color remain the tone foreground color.
+     * Supports attribute syntax: `<mlv-alert outlined>`.
+     */
+    readonly outlined: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Emits when the user clicks the dismiss button.
+     * The alert is hidden automatically after emission.
+     */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * @protected Tracks whether the alert has been dismissed by the user.
+     */
+    protected readonly _dismissed: _angular_core.WritableSignal<boolean>;
+    /**
+     * @protected Query for the optional custom icon slot directive.
+     */
+    protected readonly _iconSlot: _angular_core.Signal<MlvAlertIcon | undefined>;
+    /**
+     * @protected Query for the optional title slot directive.
+     */
+    protected readonly _titleSlot: _angular_core.Signal<MlvAlertTitle | undefined>;
+    /**
+     * @protected Handles dismiss button click: marks as dismissed and emits output.
+     */
+    protected _onDismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvAlert, "mlv-alert", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, ["_iconSlot", "_titleSlot"], ["*"], true, never>;
+}
+
+export { MlvAlert, MlvAlertIcon, MlvAlertTitle };

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

@@ -0,0 +1,301 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvOptionsInput, MlvOptionsSearchFn, MlvSelectOptionTransform, MlvOptionMatcher, MlvSelectOption } from '@malva-ui/core/dropdown';
+import { MlvDensity } from '@malva-ui/cdk/density';
+
+/** Alias of {@link MlvOptionsSearchFn} — kept for backwards compatibility. */
+type MlvAutocompleteSearchFn<T> = MlvOptionsSearchFn<T>;
+/**
+ * `[mlvAutocomplete]` — a reusable autocomplete/typeahead behaviour applicable
+ * to **any** text input: a native `<input>` or a `<mlv-input>`. It reuses the
+ * same building blocks as `mlv-combobox` — the shared
+ * {@link filterOptions matching utility} and the `mlv-dropdown-panel` list — to
+ * render a suggestion popup, without forcing the field into a full form
+ * control.
+ *
+ * Suggestions come from the {@link options} source — an array or
+ * `Observable<T[]>` (filtered locally with {@link matcher}), or a
+ * `MlvDataSource<T>` (which filters and pages itself) — or from an async
+ * {@link search} function. Every shape is normalised by the shared
+ * `MlvOptionsAdapter`. The directive owns
+ * the popup (a CDK overlay hosting `mlv-dropdown-panel`, the same primitive
+ * `mlv-popup` wraps — a headless attribute directive cannot host `mlv-popup`'s
+ * declarative content template), the WAI-ARIA combobox wiring on the input
+ * (`role="combobox"`, `aria-autocomplete="list"`, `aria-expanded`,
+ * `aria-controls`, `aria-activedescendant`), and the activedescendant keyboard
+ * model (DOM focus stays in the input; Arrow/Home/End move the highlighted
+ * option, Enter selects it, Escape closes then clears).
+ *
+ * @example
+ * ```html
+ * <!-- Static options on a plain mlv-input -->
+ * <mlv-input [mlvAutocomplete]="fruits" (optionSelected)="pick($event)" />
+ *
+ * <!-- Async search with loading + highlighting -->
+ * <mlv-input [mlvAutocompleteSearch]="searchUsers" [mlvAutocompleteMinLength]="2" />
+ *
+ * <!-- Data source: it filters (setSearch) and pages itself -->
+ * <mlv-input [mlvAutocomplete]="usersDataSource" [mlvAutocompleteMinLength]="2" />
+ *
+ * <!-- Custom matcher -->
+ * <mlv-input [mlvAutocomplete]="cities" [mlvAutocompleteMatcher]="startsWith" />
+ * ```
+ */
+declare class MlvAutocomplete<T = unknown> {
+    /**
+     * Suggestion source: a static array or `Observable<T[]>` (filtered locally
+     * against the query with {@link matcher}), or a `MlvDataSource<T>` (which owns
+     * its own filtering — the directive forwards the query as
+     * `setSearch({ query, keys: [] })` and pages lazily). Ignored when a
+     * {@link search} function is provided. Bound through the directive's own
+     * selector: `[mlvAutocomplete]="options"`.
+     */
+    readonly options: _angular_core.InputSignal<MlvOptionsInput<T>>;
+    /**
+     * Async suggestion source: `(query) => T[] | Promise<T[]> | Observable<T[]>`.
+     * When set, it supersedes {@link options}; results feed the panel and drive
+     * the loading affordance. A newer query supersedes an in-flight one (its
+     * result is discarded), while the previous results stay visible until the new
+     * ones land.
+     */
+    readonly search: _angular_core.InputSignal<MlvAutocompleteSearchFn<T> | null>;
+    /**
+     * Maps a raw item to a `MlvSelectOption` (`{ label, value, group? }`). Same
+     * convention as `mlv-select` / `mlv-combobox`; defaults to
+     * {@link defaultOptionTransform} (uses `String(item)` as the label).
+     */
+    readonly toOption: _angular_core.InputSignal<MlvSelectOptionTransform<T>>;
+    /**
+     * Predicate used to filter {@link options} against the query. Defaults to a
+     * case- and diacritic-insensitive substring match on the label. Ignored when
+     * {@link search} is provided (the async source owns its own matching).
+     */
+    readonly matcher: _angular_core.InputSignal<MlvOptionMatcher<T>>;
+    /**
+     * Debounce (ms) applied to keystrokes before filtering / searching — avoids
+     * redundant work and API calls during rapid typing.
+     * @default 200
+     */
+    readonly debounce: _angular_core.InputSignal<number>;
+    /**
+     * Minimum query length before suggestions open. `0` (default) opens on focus
+     * showing the full list — appropriate for cheap local filtering. Raise it
+     * (2+ recommended) for async sources so a network call is not made on every
+     * keystroke.
+     * @default 0
+     */
+    readonly minLength: _angular_core.InputSignal<number>;
+    /**
+     * When `true`, the matched substring of the query is emphasised inside each
+     * suggestion label.
+     * @default true
+     */
+    readonly highlight: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true` (default), an **inline completion** is offered as the user types:
+     * if the top visible suggestion's label starts with the typed text (a genuine
+     * prefix, case-insensitively) and the caret is at the end of the field, the
+     * remainder of that suggestion is inserted after the caret and left **selected**
+     * — so continuing to type replaces it, `Enter`/click commits the full value, and
+     * `Escape` reverts to just the typed text. The user's typed prefix keeps their
+     * casing; only the appended remainder uses the suggestion's casing. Non-prefix
+     * (fuzzy / substring-only) top matches are skipped silently (list-only). While
+     * enabled the input advertises `aria-autocomplete="both"`; set `false` for
+     * list-only behaviour (`aria-autocomplete="list"`).
+     * @default true
+     */
+    readonly inline: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true` (default), focusing the input opens the suggestion list
+     * (subject to {@link minLength}). Set `false` to only open on typing / arrow.
+     * @default true
+     */
+    readonly openOnFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Disables the behaviour entirely (no popup, no aria wiring changes). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Text shown / announced inside the panel's loading affordances — the top row
+     * while a remote source (an async {@link search} or a `MlvDataSource`)
+     * resolves, and the bottom row while a further page loads. Localise by binding
+     * a translated string.
+     * @default 'Loading…'
+     */
+    readonly loadingText: _angular_core.InputSignal<string>;
+    /**
+     * Distance (px) from the end of the suggestion list at which the next
+     * data-source page is requested. Only meaningful for a `MlvDataSource`
+     * {@link options} source, which is the only shape that pages.
+     * @default 150
+     */
+    readonly infiniteScrollThreshold: _angular_core.InputSignal<number>;
+    /**
+     * Density applied to the suggestion panel's option rows.
+     *
+     * The panel is hosted in a bare CDK overlay portaled to the overlay container,
+     * outside the input's DOM tree, so ancestor density classes cannot cascade
+     * into it. The resolved density is stamped as a `mlv--{density}` class on the
+     * panel host (the same mechanism `mlv-popup` uses for its detached panel).
+     * When omitted, the nearest ancestor `MLV_DENSITY_CONTEXT` (e.g. a
+     * `form[mlvForm]`) applies, then the global `MlvDensityService` density.
+     */
+    readonly density: _angular_core.InputSignal<MlvDensity | undefined>;
+    /**
+     * The raw value of the last selected suggestion, or `null`. Two-way bindable
+     * (`[(mlvAutocompleteValue)]`) so a parent can observe the committed pick.
+     */
+    readonly selectedValue: _angular_core.ModelSignal<T | null>;
+    /** Emits the full `MlvSelectOption` each time the user selects a suggestion. */
+    readonly optionSelected: _angular_core.OutputEmitterRef<MlvSelectOption<T>>;
+    /** Emits `true` when the suggestion list opens and `false` when it closes. */
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    /** @private Host element the directive is applied to (native input or mlv-input). */
+    private readonly _hostEl;
+    /** @private Renderer for DOM attribute/listener wiring on the resolved input. */
+    private readonly _renderer;
+    /** @private CDK overlay factory used to host the suggestion panel. */
+    private readonly _overlay;
+    /** @private View container + injector for the `mlv-dropdown-panel` component portal. */
+    private readonly _vcr;
+    private readonly _injector;
+    /** @private Directive lifetime, for imperative listener / subscription cleanup. */
+    private readonly _destroyRef;
+    /** @private Global density service — fallback when no explicit {@link density} is supplied. */
+    private readonly _densityService;
+    private readonly _rtlService;
+    /** @private Ancestor-projected density (`MLV_DENSITY_CONTEXT`); consulted before the service. */
+    private readonly _densityContext;
+    /** @private The resolved focusable `<input>` (host itself, or the inner input of a `mlv-input`). */
+    private readonly _inputEl;
+    /** @private Current (post-input) query text. */
+    private readonly _query;
+    /** @private The current suggestion options rendered in the panel. */
+    private readonly _results;
+    /**
+     * @private Shared source adapter: arrays / observables filter locally, a
+     * `MlvDataSource` or `search` fn run remotely. Debounce is 0 here because the
+     * directive already debounces keystrokes before `_runQuery`.
+     */
+    private readonly _adapter;
+    /** @private Panel loading flag — only remote sources report loading. */
+    private readonly _panelLoading;
+    /**
+     * @private Shared activedescendant bookkeeping: tracks the highlighted option
+     * index over the current results with wrap-around navigation. The same engine
+     * backs `mlv-combobox`.
+     */
+    private readonly _activeDescendant;
+    /** @private Whether the suggestion popup is open. */
+    private readonly _open;
+    /** @private The attached panel component ref (a signal so the sync effect re-runs on attach). */
+    private readonly _panelRef;
+    /** Whether the suggestion popup is currently open (read-only view of internal state). */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    /** @private Stable listbox id shared between the input's `aria-controls` and the panel's option ids. */
+    private readonly _listboxId;
+    /**
+     * @private Debounced keystroke stream. Carries the query text plus whether the
+     * triggering edit was an insertion (text grew) so the debounced `_runQuery`
+     * knows whether an inline completion may be offered — only genuine insertions
+     * complete, never deletions (Backspace/Delete/cut), focus, or arrow-open.
+     */
+    private readonly _input$;
+    /** @private Skips the synthetic `input` event dispatched while committing / completing a value. */
+    private _suppressNextInput;
+    /** @private Live overlay reference while the panel is open. */
+    private _overlayRef;
+    /**
+     * @private `inputType` of the pending native edit, captured on `beforeinput`
+     * and consumed on `input`. Non-null in real browsers (drives precise
+     * insert-vs-delete detection); `null` in environments that don't fire
+     * `beforeinput` (jsdom / programmatic edits), where a length comparison is the
+     * fallback.
+     */
+    private _pendingInputType;
+    /** @private Length of the input value at the previous `input` event — the length-comparison fallback for insertion detection. */
+    private _previousValueLength;
+    /** @private Whether the current query is allowed to offer an inline completion (set per `_runQuery`; only true for inline-enabled insertions). */
+    private _completionArmed;
+    /** @private Whether an inline completion (typed prefix + selected remainder) is currently present in the input. */
+    private _completionActive;
+    /** @private The `mlv--{density}` class currently applied to the panel host, for removal on change. */
+    private _appliedDensityClass;
+    constructor();
+    /**
+     * @private Resolves the focusable `<input>` and attaches the native listeners
+     * (input / focus / blur / keydown) that drive the behaviour. Cleaned up on
+     * directive destroy.
+     */
+    private _bindTo;
+    /**
+     * @private `aria-activedescendant` target: the DOM id of the highlighted
+     * option row, or `null` when nothing is active. Matches the id the panel
+     * renders (`<listboxId>-option-<index>`).
+     */
+    private readonly _activeOptionId;
+    /** @private Handles a native `input` event: pushes the value (with insertion flag) into the debounced stream. */
+    private _onInput;
+    /**
+     * @private Whether the just-observed `input` event grew the field's text (a
+     * genuine insertion) rather than deleting from it. Prefers the `beforeinput`
+     * `inputType` when available (real browsers), else compares the value length
+     * against the previous `input` event. Consumes the pending type and records
+     * the new length either way.
+     */
+    private _consumeInsertion;
+    /** @private Opens suggestions on focus (immediate, bypassing debounce) when enabled. */
+    private _onFocus;
+    /** @private Closes the popup when focus genuinely leaves the field. */
+    private _onBlur;
+    /** @private Activedescendant keyboard model — DOM focus stays in the input. */
+    private _onKeydown;
+    /**
+     * @private Resolves suggestions for `query` and opens / closes the popup.
+     * Local sources (arrays / observables) filter synchronously; a remote source
+     * (a `MlvDataSource` or an async {@link search}) shows the loading affordance
+     * while keeping the previous results visible, and a newer query supersedes it.
+     */
+    private _runQuery;
+    /**
+     * @private Offers an inline completion for the current results: if the top
+     * suggestion's label is a genuine case-insensitive **prefix** of the typed
+     * text and the caret sits at the end of the field, append the suggestion's
+     * remainder (in its own casing) after the typed prefix (kept in the user's
+     * casing) and leave that remainder **selected**. The completed value is pushed
+     * through the same synthetic-`input` path a commit uses so `mlv-input` /
+     * `ngModel` / a form control observe it, and the top item (index 0) becomes the
+     * activedescendant-active row. No-op unless armed for an inline insertion with
+     * an open panel; non-prefix (fuzzy) top matches are skipped silently.
+     */
+    private _applyCompletion;
+    /**
+     * @private Strips an active inline completion back to the typed prefix (the
+     * text before the selected remainder), restoring the caret to the end and
+     * notifying value listeners. Returns whether a completion was stripped.
+     */
+    private _stripCompletion;
+    /**
+     * Panel (pointer) selection handler — subscribed to the `mlv-dropdown-panel`
+     * `valueChange`. The panel is never seeded with a committed selection
+     * (`selectedValues` is always `[]`), so any non-empty emit is a genuine pick —
+     * no aria reconciliation guard is needed. Public so the overlay subscription
+     * (and unit tests) can invoke it.
+     */
+    selectFromPanel(values: readonly T[]): void;
+    /** @private Commits a suggestion: writes its full label into the input (caret to end), emits, and closes. */
+    private _commit;
+    /** @private Clears the input text (second Escape) and notifies listeners. */
+    private _clearInput;
+    /** @private Creates (if needed) and shows the suggestion overlay. */
+    private _openPopup;
+    /** @private Hides and disposes the overlay, resetting popup state. */
+    private _closePopup;
+    /** @private Tears down the overlay + panel ref. */
+    private _disposeOverlay;
+    /** @private Whether all interaction paths are suppressed. */
+    private _isInert;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvAutocomplete<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvAutocomplete<any>, "[mlvAutocomplete],[mlvAutocompleteSearch]", ["mlvAutocomplete"], { "options": { "alias": "mlvAutocomplete"; "required": false; "isSignal": true; }; "search": { "alias": "mlvAutocompleteSearch"; "required": false; "isSignal": true; }; "toOption": { "alias": "mlvAutocompleteToOption"; "required": false; "isSignal": true; }; "matcher": { "alias": "mlvAutocompleteMatcher"; "required": false; "isSignal": true; }; "debounce": { "alias": "mlvAutocompleteDebounce"; "required": false; "isSignal": true; }; "minLength": { "alias": "mlvAutocompleteMinLength"; "required": false; "isSignal": true; }; "highlight": { "alias": "mlvAutocompleteHighlight"; "required": false; "isSignal": true; }; "inline": { "alias": "mlvAutocompleteInline"; "required": false; "isSignal": true; }; "openOnFocus": { "alias": "mlvAutocompleteOpenOnFocus"; "required": false; "isSignal": true; }; "disabled": { "alias": "mlvAutocompleteDisabled"; "required": false; "isSignal": true; }; "loadingText": { "alias": "mlvAutocompleteLoadingText"; "required": false; "isSignal": true; }; "infiniteScrollThreshold": { "alias": "mlvAutocompleteInfiniteScrollThreshold"; "required": false; "isSignal": true; }; "density": { "alias": "mlvAutocompleteDensity"; "required": false; "isSignal": true; }; "selectedValue": { "alias": "mlvAutocompleteValue"; "required": false; "isSignal": true; }; }, { "selectedValue": "mlvAutocompleteValueChange"; "optionSelected": "optionSelected"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+export { MlvAutocomplete };
+export type { MlvAutocompleteSearchFn };