@malva-ui/core 0.1.12

package/select/lib/select/select.d.ts

@@ -0,0 +1,379 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { ConnectedPosition } from '@angular/cdk/overlay';
+import type { MlvPopupMobileMode } from '@malva-ui/core/popup';
+import type { MlvFormState, MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSelectionService, MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import { MlvSelectItemTemplate, MlvSelectSelectedTemplate } from '../select-template.directives';
+import type { MlvDensity } from '@malva-ui/cdk/density';
+import { MlvOptionsAdapter } from '@malva-ui/core/dropdown';
+import type { MlvOptionMatcher, MlvOptionsInput, MlvOptionsSearchFn } from '@malva-ui/core/dropdown';
+import type { MlvSelectOptionTransform } from '../select-option';
+import * as i0 from "@angular/core";
+/**
+ * Visual/validation state of the select. Mirrors {@link MlvFormState}.
+ */
+export type MlvSelectState = MlvFormState;
+export 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: import("@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: import("@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: import("@angular/core").InputSignal<MlvOptionsSearchFn<T> | null>;
+    /** Debounce (ms) for remote searches (`MlvDataSource` / {@link searchFn}). Local filtering stays instant. */
+    readonly searchDebounce: import("@angular/core").InputSignal<number>;
+    /** Enables multi-selection mode. */
+    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Custom placeholder override. Falls back to the i18n-provided placeholder. */
+    readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
+    readonly toOption: import("@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: import("@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: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Placeholder of the in-dropdown search field. Falls back to the i18n default. */
+    readonly searchPlaceholder: import("@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: import("@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: import("@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: import("@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: import("@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: import("@angular/core").Signal<string>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvSelectI18n>;
+    protected readonly _formI18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvFormUtilsI18n>;
+    /** @protected Resolved placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedPlaceholder: import("@angular/core").Signal<string>;
+    readonly focused: import("@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: import("@angular/core").Signal<import("@malva-ui/core/dropdown").MlvSelectOption<T>[]>;
+    /** @protected Whether every committed value has a matching option (by `compareWith`). */
+    protected readonly _allValuesMatched: import("@angular/core").Signal<boolean>;
+    /** @protected First payload arrived and the consumer is not reporting `loading`. */
+    protected readonly _ready: import("@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: import("@angular/core").Signal<boolean>;
+    /** @protected Panel spinner row: source-owned loading OR the consumer's `[loading]`. */
+    protected readonly _panelLoading: import("@angular/core").Signal<boolean>;
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly triggerWidth: import("@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: import("@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: import("@angular/core").Signal<import("@malva-ui/core/dropdown").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: import("@angular/core").Signal<number>;
+    /** @protected `aria-activedescendant` target of the search input, or `null`. */
+    protected readonly _activeOptionId: import("@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: import("@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: import("@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: import("@angular/core").Signal<string>;
+    /** @protected Resolved search placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedSearchPlaceholder: import("@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: import("@angular/core").Signal<string>;
+    /** The HTML `id` assigned to the inner listbox element for `aria-controls` linking. */
+    readonly listboxId: import("@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: import("@angular/core").Signal<string>;
+    readonly dropdownPositions: ConnectedPosition[];
+    readonly selectionService: MlvSelectionService<any>;
+    itemTemplate: import("@angular/core").Signal<MlvSelectItemTemplate | undefined>;
+    selectedTemplate: import("@angular/core").Signal<MlvSelectSelectedTemplate | undefined>;
+    /** @private Reference to the trigger element, used to restore focus after selection. */
+    private readonly _triggerElement;
+    /** @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 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: import("@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: import("@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: import("@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: i0.ɵɵFactoryDeclaration<MlvSelect<any>, never>;
+    static ɵcmp: i0.ɵɵ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; }; "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>;
+}

package/select/lib/select-option.d.ts

@@ -0,0 +1 @@
+export * from '@malva-ui/core/dropdown';

package/select/lib/select-template.directives.d.ts

@@ -0,0 +1,14 @@
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class MlvSelectListTemplate extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSelectListTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSelectListTemplate, "[mlvSelectListTemplate]", never, {}, {}, never, never, true, never>;
+}
+export declare class MlvSelectItemTemplate extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSelectItemTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSelectItemTemplate, "[mlvSelectItemTemplate]", never, {}, {}, never, never, true, never>;
+}
+export declare class MlvSelectSelectedTemplate extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSelectSelectedTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSelectSelectedTemplate, "[mlvSelectSelectedTemplate]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/select" />
+export * from './index';

package/sidebar/index.d.ts

@@ -0,0 +1,15 @@
+export * from './lib/sidebar/sidebar';
+export * from './lib/sidebar-group/sidebar-group';
+export * from './lib/sidebar-item/sidebar-item';
+export * from './lib/sidebar-item-icon';
+export * from './lib/sidebar-item-host';
+export * from './lib/sidebar-context';
+export * from './lib/sidebar-mode';
+export * from './lib/sidebar-header';
+export * from './lib/sidebar-footer';
+export * from './lib/sidebar-content';
+export * from './lib/sidebar-rail/sidebar-rail';
+export * from './lib/sidebar-trigger/sidebar-trigger';
+export * from './lib/sidebar-workspace/sidebar-workspace';
+export * from './lib/sidebar-workspace/sidebar-workspace.directives';
+export * from './lib/sidebar-workspace/sidebar-workspace.types';

package/sidebar/lib/sidebar/sidebar.d.ts

@@ -0,0 +1,134 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvBreakpoint } from '@malva-ui/cdk/utils';
+import type { MlvSidebarContextValue } from '../sidebar-context';
+import type { MlvSidebarMode } from '../sidebar-mode';
+import { MlvSidebarHeader } from '../sidebar-header';
+import { MlvSidebarFooter } from '../sidebar-footer';
+import { SidebarContentDirective } from '../sidebar-content';
+import * as i0 from "@angular/core";
+export declare class MlvSidebar implements MlvSidebarContextValue {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvSidebarI18n>;
+    /**
+     * @private Signal-based viewport breakpoint service. Wraps the CDK
+     * `BreakpointObserver`, so it is SSR-safe — no direct `matchMedia` access.
+     */
+    private readonly _breakpoint;
+    /**
+     * @private Collapsed value captured when the responsive override kicked in,
+     * so leaving the breakpoint restores what the author/user had before.
+     * `null` while no responsive override is active.
+     */
+    private _collapsedBeforeAutoOffcanvas;
+    /**
+     * Controls expanded vs. collapsed (icon-only) mode.
+     * Accepts truthy strings via `coerceBooleanProperty`.
+     * Two-way bindable via `[(collapsed)]`.
+     */
+    readonly collapsed: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Total width of the sidebar host when expanded, including border and padding.
+     * Two-way bindable — updated by `setWidth()` during rail drag.
+     */
+    readonly width: import("@angular/core").ModelSignal<string>;
+    /**
+     * Total width of the sidebar host when collapsed, including border and padding.
+     */
+    readonly collapsedWidth: import("@angular/core").InputSignal<string>;
+    /**
+     * MlvLayout mode controlling how the sidebar renders and collapses.
+     * - `'icon'` — collapses to an icon-only rail (default).
+     * - `'offcanvas'` — slides off-screen when collapsed.
+     * - `'floating'` — floats over content when expanded.
+     * - `'fixed'` — always fully expanded; collapse is a no-op.
+     */
+    readonly mode: import("@angular/core").InputSignal<MlvSidebarMode>;
+    /**
+     * Viewport breakpoint below which the sidebar automatically behaves as an
+     * `'offcanvas'` drawer, regardless of {@link mode}.
+     *
+     * `null` (the default) keeps the sidebar on {@link mode} at every width.
+     * Setting it to `'md'` makes the sidebar an overlay drawer below 768px — it
+     * closes itself on entering that range, opens from a `mlv-sidebar-trigger`,
+     * and dismisses on Escape, backdrop click, or focus leaving the drawer, like
+     * any `mode="offcanvas"` sidebar. The previous collapsed state is restored
+     * when the viewport grows back past the breakpoint.
+     *
+     * Thresholds come from `MLV_BREAKPOINT_CONFIG` (`provideMlvBreakpoints()`),
+     * so they stay in sync with the SCSS `breakpoint-*` mixins.
+     */
+    readonly collapseBelow: import("@angular/core").InputSignal<MlvBreakpoint | null>;
+    /**
+     * When true, the sidebar stretches to full viewport height.
+     * Adds the `mlv-sidebar--full-height` modifier class.
+     */
+    readonly fullHeight: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Accessible name for the `navigation` landmark.
+     *
+     * Set this whenever a page renders more than one sidebar (or another
+     * `navigation` landmark) so assistive technology can tell them apart.
+     * When omitted, the localized `MLV_SIDEBAR_I18N.navigation` default is used.
+     *
+     * Note: a plain `aria-label` attribute on `<mlv-sidebar>` cannot be used for
+     * this — the host binding owns the attribute and would overwrite it.
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Minimum width in pixels the sidebar may be resized to via the drag rail.
+     */
+    readonly minWidth: import("@angular/core").InputSignal<number>;
+    /**
+     * Maximum width in pixels the sidebar may be resized to via the drag rail.
+     */
+    readonly maxWidth: import("@angular/core").InputSignal<number>;
+    /**
+     * @private True when {@link collapseBelow} is set and the viewport is
+     * narrower than that breakpoint.
+     */
+    private readonly _isBelowCollapseBreakpoint;
+    /**
+     * The layout mode actually in effect.
+     *
+     * Equals {@link mode} unless {@link collapseBelow} is set and the viewport is
+     * narrower than that breakpoint, in which case it is `'offcanvas'`. Bind
+     * against this (not `mode`) when mirroring the sidebar's layout elsewhere.
+     */
+    readonly effectiveMode: import("@angular/core").Signal<MlvSidebarMode>;
+    /**
+     * Effective collapsed state. Always `false` in `'fixed'` mode so the sidebar
+     * never visually collapses regardless of the `collapsed` model value.
+     */
+    protected readonly _effectiveCollapsed: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Accessible name bound to the host `aria-label`. Prefers the
+     * author-supplied {@link ariaLabel} and falls back to the localized default.
+     */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string>;
+    /** @protected Header slot directive reference. */
+    protected readonly _headerRef: import("@angular/core").Signal<MlvSidebarHeader | undefined>;
+    /** @protected Footer slot directive reference. */
+    protected readonly _footerRef: import("@angular/core").Signal<MlvSidebarFooter | undefined>;
+    /** @protected Content slot directive reference. */
+    protected readonly _contentRef: import("@angular/core").Signal<SidebarContentDirective | undefined>;
+    /** @protected True when at least one slot directive is projected. */
+    protected readonly _hasSlots: import("@angular/core").Signal<boolean>;
+    constructor();
+    /**
+     * Toggles the sidebar between collapsed and expanded.
+     * This is a no-op when the effective mode is `'fixed'`.
+     */
+    toggle(): void;
+    /** Set the sidebar width in pixels. Clamps to the [minWidth, maxWidth] range. */
+    setWidth(px: number): void;
+    /** @protected Syncs drawer open/close back to collapsed model. */
+    protected _onDrawerOpenedChange(opened: boolean): void;
+    /**
+     * @protected Handles `ArrowDown`/`ArrowUp` keydown events on the sidebar container
+     * to move focus between focusable sidebar items and group triggers in DOM order.
+     * Wraps around at the list boundaries and skips elements inside `.cdk-overlay-container`.
+     */
+    protected onContainerKeydown(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebar, "mlv-sidebar", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "collapsedWidth": { "alias": "collapsedWidth"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "collapseBelow": { "alias": "collapseBelow"; "required": false; "isSignal": true; }; "fullHeight": { "alias": "fullHeight"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; "width": "widthChange"; }, ["_headerRef", "_footerRef", "_contentRef"], ["*"], true, never>;
+}

package/sidebar/lib/sidebar-content.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+/**
+ * Marks the scrollable middle region between header and footer inside the sidebar.
+ * Gets `flex: 1 1 0` so it fills the remaining space. Intended to hold sidebar items and groups.
+ */
+export declare class MlvSidebarContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebarContent, "[mlvSidebarContent]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Backwards-compatible public name retained for existing imports. */
+export { MlvSidebarContent as SidebarContentDirective };

package/sidebar/lib/sidebar-context.d.ts

@@ -0,0 +1,23 @@
+import type { Signal } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MlvSidebarMode } from './sidebar-mode';
+export interface MlvSidebarContextValue {
+    /** Whether the sidebar is collapsed. */
+    readonly collapsed: Signal<boolean>;
+    /** Whether the current rendering context is inside a flyout popup. */
+    readonly inFlyout?: Signal<boolean>;
+    /** The layout mode requested by the author. */
+    readonly mode: Signal<MlvSidebarMode>;
+    /**
+     * The layout mode actually in effect. Equals {@link mode} unless a
+     * responsive override (`MlvSidebar.collapseBelow`) is active, in which case
+     * it reports `'offcanvas'`. Optional so externally implemented contexts stay
+     * valid — read it as `effectiveMode?.() ?? mode()`.
+     */
+    readonly effectiveMode?: Signal<MlvSidebarMode>;
+    /** Toggle between collapsed and expanded. */
+    toggle(): void;
+    /** Set the sidebar width in pixels (used by the rail during drag). */
+    setWidth(px: number): void;
+}
+export declare const SIDEBAR_CONTEXT: InjectionToken<MlvSidebarContextValue>;

package/sidebar/lib/sidebar-footer.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+/**
+ * Marks a sticky bottom region inside the sidebar.
+ * Applied to a container element that should remain visible at the bottom when content scrolls.
+ */
+export declare class MlvSidebarFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarFooter, "[mlvSidebarFooter]", never, {}, {}, never, never, true, never>;
+}