@malva-ui/core 0.1.12

package/slider/lib/slider/slider.d.ts

@@ -0,0 +1,171 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import { MlvSliderTooltipDef, type MlvSliderTooltipDefContext } from './slider-tooltip-def';
+import * as i0 from "@angular/core";
+import * as i1 from "@malva-ui/cdk/density";
+/**
+ * The value type for the slider in single-thumb mode (number) or
+ * dual-thumb range mode ([number, number]).
+ */
+export type MlvSliderValue = number | [number, number];
+export declare class MlvSlider extends MlvSignalFormControlBase<MlvSliderValue> implements MlvFormControl {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvSliderI18n>;
+    /**
+     * Orientation of the slider.
+     * In `'vertical'` mode the track runs bottom-to-top, thumbs are positioned
+     * with `bottom`, and the host must have an explicit height set.
+     */
+    readonly orientation: import("@angular/core").InputSignal<"horizontal" | "vertical">;
+    /** Minimum value of the slider. */
+    readonly min: import("@angular/core").InputSignalWithTransform<number, MlvSliderValue | null | undefined>;
+    /** Maximum value of the slider. */
+    readonly max: import("@angular/core").InputSignalWithTransform<number, MlvSliderValue | null | undefined>;
+    /** Step increment between values. */
+    readonly step: import("@angular/core").InputSignalWithTransform<number, number | null | undefined>;
+    /** Whether to display tick marks at each step interval. */
+    readonly showTicks: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** When true, the slider operates in dual-thumb range mode. */
+    readonly range: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Shows the current value in a tooltip while a thumb is hovered, dragged,
+     * or keyboard-focused.
+     */
+    readonly tooltip: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** The selected scalar or range value used by all Angular forms APIs. */
+    readonly value: import("@angular/core").ModelSignal<MlvSliderValue>;
+    /** @protected Optional consumer template used to render tooltip text. */
+    protected readonly _tooltipDef: import("@angular/core").Signal<MlvSliderTooltipDef | undefined>;
+    /** @private True when orientation is vertical. */
+    protected readonly _isVertical: import("@angular/core").Signal<boolean>;
+    /** @private Low (or sole) thumb value derived directly from the forms model. */
+    protected readonly _lowValue: import("@angular/core").Signal<number>;
+    /** @private High thumb value derived directly from the forms model. */
+    protected readonly _highValue: import("@angular/core").Signal<number>;
+    /** @protected Template context for the low or single-value thumb tooltip. */
+    protected readonly _lowTooltipContext: import("@angular/core").Signal<MlvSliderTooltipDefContext>;
+    /** @protected Template context for the high thumb tooltip in range mode. */
+    protected readonly _highTooltipContext: import("@angular/core").Signal<MlvSliderTooltipDefContext>;
+    /**
+     * @private The thumb currently being dragged: 'low', 'high', or null.
+     */
+    protected readonly _activeDragThumb: import("@angular/core").WritableSignal<"low" | "high" | null>;
+    /**
+     * @private Raw drag position (0–100%) for the low thumb while dragging.
+     * Null when not dragging — thumb reverts to the snapped value's position.
+     */
+    private readonly _lowDragPercent;
+    /**
+     * @private Raw drag position (0–100%) for the high thumb while dragging.
+     * Null when not dragging — thumb reverts to the snapped value's position.
+     */
+    private readonly _highDragPercent;
+    /**
+     * @private Visual percentage position of the low thumb.
+     * Uses the raw drag position while dragging for a smooth feel;
+     * snaps back to the step-aligned position on pointer release.
+     */
+    protected readonly _lowPercent: import("@angular/core").Signal<number>;
+    /**
+     * @private Visual percentage position of the high thumb.
+     * Uses the raw drag position while dragging for a smooth feel;
+     * snaps back to the step-aligned position on pointer release.
+     */
+    protected readonly _highPercent: import("@angular/core").Signal<number>;
+    /**
+     * @private Computed percentage for the fill region start (0–100%).
+     * In single mode this is always 0; in range mode it tracks the low thumb visual position.
+     */
+    protected readonly _fillStart: import("@angular/core").Signal<string>;
+    /**
+     * @private Computed percentage for the fill region end (0–100%).
+     * Tracks the visual (drag or snapped) position of the active thumb.
+     */
+    protected readonly _fillEnd: import("@angular/core").Signal<string>;
+    /**
+     * @private Array of tick positions (percentages) shown when showTicks is true.
+     */
+    protected readonly _ticks: import("@angular/core").Signal<number[]>;
+    constructor();
+    /** @private Host element ref for pointer-to-value calculation. */
+    private _elementRef;
+    /** @private Renderer2 for SSR-safe + auto-cleanup window listeners during drag. */
+    private _renderer;
+    /** @private DestroyRef so a destroy mid-drag releases the listeners. */
+    private _destroyRef;
+    /**
+     * @private The `.mlv-slider__track` element — a static child of this
+     * component's own template, so it is resolved via a signal `viewChild` query
+     * (repo rule: no `querySelector` for own-template elements) rather than a DOM
+     * lookup on the host.
+     */
+    private readonly _trackRef;
+    /**
+     * @private Track bounding rect captured at pointerdown and reused for the whole
+     * drag, so `_pointerToPercent` does not force a `getBoundingClientRect` layout
+     * read on every pointermove. Dropped when the pointer ends or is cancelled.
+     */
+    private _dragTrackRect;
+    /** Whether the control holds a clearable value — A slider always carries a numeric value. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Handles keydown events on the low thumb.
+     */
+    protected _onLowThumbKeydown(event: KeyboardEvent): void;
+    /**
+     * @protected Handles keydown events on the high thumb (range mode only).
+     */
+    protected _onHighThumbKeydown(event: KeyboardEvent): void;
+    /**
+     * @protected Handles pointerdown events on the track area to begin thumb dragging.
+     */
+    protected _onTrackPointerDown(event: PointerEvent): void;
+    /**
+     * @private Attaches pointermove/end listeners on the window for drag tracking.
+     * During drag the thumb follows the pointer freely (no step snapping) while the
+     * emitted value snaps to the nearest step on every move. On pointer release the
+     * raw drag position is cleared so the thumb animates to the snapped position.
+     */
+    private _attachPointerListeners;
+    /**
+     * @private Converts a keyboard event into a new value, or null if unhandled.
+     */
+    private _computeKeyValue;
+    /**
+     * @private Converts a pointer event position to a clamped percentage (0–100).
+     * Horizontal: left → 0%, right → 100%.
+     * Vertical: bottom → 0%, top → 100% (inverted Y axis).
+     * Does not snap — use this for free drag tracking.
+     */
+    private _pointerToPercent;
+    /**
+     * @private Converts a pointer event's X position to a clamped, snapped slider value.
+     * Used for track clicks (immediate snap) — not for drag moves.
+     */
+    private _pointerEventToValue;
+    /**
+     * @private Converts a value to a percentage between 0 and 100.
+     */
+    private _valueToPercent;
+    /**
+     * @private Clamps a value to [min, max].
+     */
+    private _clamp;
+    /**
+     * @private Snaps a value to the nearest step.
+     */
+    private _snap;
+    /** @private Writes the low/sole thumb while preserving the range shape. */
+    private _setLowValue;
+    /** @private Writes the high thumb while preserving the current low value. */
+    private _setHighValue;
+    /**
+     * @private Writes the current value through the signal-forms model.
+     */
+    private _emitChange;
+    /** @protected Marks the control touched when either thumb loses focus. */
+    protected _onThumbBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSlider, "mlv-slider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showTicks": { "alias": "showTicks"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_tooltipDef"], never, true, [{ directive: typeof i1.MlvCompactComfortableDensity; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}

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

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

package/split-pane/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/split-pane/split-pane';
+export * from './lib/split-pane/split-pane-panel';
+export * from './lib/split-pane/split-pane.types';

package/split-pane/lib/split-pane/split-pane-panel.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Individual panel inside a `mlv-split-pane`.
+ *
+ * Panels are placed side-by-side (horizontal) or stacked (vertical) with a
+ * draggable handle between each pair. The parent component manages all sizes
+ * and inserts the handles automatically.
+ *
+ * @example
+ * ```html
+ * <mlv-split-pane>
+ *   <mlv-split-pane-panel [size]="30">Sidebar</mlv-split-pane-panel>
+ *   <mlv-split-pane-panel>Main content</mlv-split-pane-panel>
+ * </mlv-split-pane>
+ * ```
+ */
+export declare class MlvSplitPanePanel {
+    /** @internal Direct reference to the host element, used by the parent for DOM measurement. */
+    readonly _elementRef: ElementRef<any>;
+    /**
+     * Initial size of this panel as a percentage of the container.
+     * When omitted the panel shares the remaining space equally with other unsized panels.
+     */
+    readonly size: import("@angular/core").InputSignal<number | undefined>;
+    /**
+     * Minimum size of this panel as a percentage.
+     * Drag and keyboard resize will not reduce this panel below this value.
+     * Defaults to `5`.
+     */
+    readonly minSize: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSplitPanePanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSplitPanePanel, "mlv-split-pane-panel", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "minSize": { "alias": "minSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/split-pane/lib/split-pane/split-pane.d.ts

@@ -0,0 +1,98 @@
+import { type AfterContentInit } from '@angular/core';
+import type { MlvSplitPaneOrientation } from './split-pane.types';
+import * as i0 from "@angular/core";
+/**
+ * Split pane container that divides space into two or more resizable panels.
+ *
+ * Panels are declared as `<mlv-split-pane-panel>` children. The component
+ * automatically inserts a drag handle between each adjacent pair. Sizes are
+ * managed via CSS `grid-template-columns` (horizontal) or
+ * `grid-template-rows` (vertical), ensuring the DOM always reflects the true
+ * rendered widths/heights.
+ *
+ * @example Basic 2-panel
+ * ```html
+ * <mlv-split-pane style="height: 300px;">
+ *   <mlv-split-pane-panel [size]="30">Sidebar</mlv-split-pane-panel>
+ *   <mlv-split-pane-panel>Main</mlv-split-pane-panel>
+ * </mlv-split-pane>
+ * ```
+ *
+ * @example 3-panel
+ * ```html
+ * <mlv-split-pane style="height: 300px;">
+ *   <mlv-split-pane-panel [size]="20">Nav</mlv-split-pane-panel>
+ *   <mlv-split-pane-panel>Editor</mlv-split-pane-panel>
+ *   <mlv-split-pane-panel [size]="25">Properties</mlv-split-pane-panel>
+ * </mlv-split-pane>
+ * ```
+ */
+export declare class MlvSplitPane implements AfterContentInit {
+    /**
+     * Orientation of the split. `'horizontal'` places panels side-by-side;
+     * `'vertical'` stacks them top to bottom.
+     */
+    readonly orientation: import("@angular/core").InputSignal<MlvSplitPaneOrientation>;
+    /** @protected Whether a drag is currently in progress. Drives the `--dragging` modifier class. */
+    protected readonly _isDragging: import("@angular/core").WritableSignal<boolean>;
+    /** @private Queried panel children. */
+    private readonly _panels;
+    /** @private Current sizes of each panel in `fr` units (≈ percentage). */
+    private readonly _sizes;
+    /**
+     * @private Latest sizes produced during an active pointer drag. The drag
+     * stream runs outside Angular and mutates the grid template imperatively; this
+     * buffer holds the running value so it can be committed to the `_sizes` signal
+     * exactly once, on pointerup, inside the zone.
+     */
+    private _dragSizes;
+    /** @private The inserted drag-handle elements, indexed by the pair they split. */
+    private readonly _handles;
+    /** @private Host element reference. */
+    private readonly _elementRef;
+    /** @private Angular Renderer2 for all DOM mutations. */
+    private readonly _renderer;
+    /** @private DestroyRef for observable cleanup. */
+    private readonly _destroyRef;
+    /** @private Angular zone — the drag stream runs outside it to avoid a change-detection pass per pointermove. */
+    private readonly _ngZone;
+    ngAfterContentInit(): void;
+    /**
+     * @private Calculates the initial size for each panel.
+     * Panels with an explicit `size` input use that value.
+     * Panels without one share the remaining percentage equally.
+     */
+    private _computeInitialSizes;
+    /**
+     * @private Updates `grid-template-columns` (horizontal) or `grid-template-rows`
+     * (vertical) so each panel occupies its current `fr` share. Handles always
+     * occupy a fixed `0.125rem` track, so they never eat into panel space.
+     */
+    private _applyGridTemplate;
+    /**
+     * @private Syncs the ARIA window-splitter values on every drag handle.
+     * A focusable `role="separator"` is a window splitter and therefore requires
+     * `aria-valuenow` (with `aria-valuemin`/`aria-valuemax`). `aria-valuenow`
+     * tracks the leading panel's size (%), bounded by the two adjacent panels'
+     * `minSize` values.
+     */
+    private _updateHandleAria;
+    /**
+     * @private Creates and returns a drag handle DOM element for the given handle index.
+     * The grip visual is drawn entirely with CSS — no Angular directives required.
+     */
+    private _createHandle;
+    /**
+     * @private Wires pointer-capture drag behavior for a single handle.
+     * Only the two panels adjacent to the handle change size during drag;
+     * all other panels remain fixed.
+     */
+    private _initDragForHandle;
+    /**
+     * @protected Keyboard handler on each dynamically created handle.
+     * Arrow keys move by 1%, Home/End jump to the adjacent panel's minSize.
+     */
+    private _onHandleKeydown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSplitPane, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSplitPane, "mlv-split-pane", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, ["_panels"], ["*"], true, never>;
+}

package/split-pane/lib/split-pane/split-pane.types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Orientation of the split pane.
+ *
+ * - `'horizontal'` — panes are side by side (left | right), drag handle is vertical
+ * - `'vertical'` — panes are stacked (top | bottom), drag handle is horizontal
+ */
+export type MlvSplitPaneOrientation = 'horizontal' | 'vertical';

package/split-pane/malva-ui-core-split-pane.d.ts

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

package/status-indicator/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/status-indicator/status-indicator';

package/status-indicator/lib/status-indicator/status-indicator.d.ts

@@ -0,0 +1,61 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+/**
+ * Available tone variants for the status indicator.
+ * Extends the shared {@link MlvTone} semantic vocabulary with neutral and
+ * brand options — mirroring `MlvBadgeTone` / `MlvChipTone` — so a dot's colour stays
+ * consistent with the badge/chip it commonly sits beside.
+ */
+export type MlvStatusIndicatorTone = MlvTone | 'default' | 'primary' | 'secondary' | 'accent';
+/**
+ * Small circular status dot for conveying presence, health, or state (online,
+ * busy, error, …). Renders a `0.5rem` (8px) coloured dot using the same
+ * semantic {@link MlvStatusIndicatorTone} vocabulary as `mlv-badge` / `mlv-chip`,
+ * with an optional infinite ripple pulse.
+ *
+ * Decorative by default (`aria-hidden`); provide {@link MlvStatusIndicator.ariaLabel}
+ * to expose an accessible name (`role="img"`) when the dot carries meaning that
+ * is not conveyed by adjacent text.
+ *
+ * @example
+ * ```html
+ * <mlv-status-indicator tone="success" pulse />
+ * <mlv-status-indicator tone="danger" ariaLabel="Offline" />
+ * <span><mlv-status-indicator tone="warning" /> Degraded</span>
+ * ```
+ */
+export declare class MlvStatusIndicator {
+    /**
+     * The semantic tone of the dot, mapped to a solid fill colour token.
+     * Defaults to `'default'` (neutral grey).
+     */
+    readonly tone: import("@angular/core").InputSignal<MlvStatusIndicatorTone>;
+    /**
+     * When `true`, an expanding ripple ring animates outward from the dot on an
+     * infinite loop to draw attention (e.g. "live"/"recording" states).
+     * Respects `prefers-reduced-motion: reduce`, which suppresses the ripple.
+     * Supports attribute usage: `<mlv-status-indicator pulse>`.
+     */
+    readonly pulse: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Diameter of the dot in pixels. Defaults to `8` (`0.5rem`), matching the
+     * design spec. Converted to `rem` internally so the dot scales with the
+     * user's root font-size. Overridable per-instance (e.g. `[size]="4"`).
+     */
+    readonly size: import("@angular/core").InputSignal<number>;
+    /**
+     * Optional accessible name. When set, the dot is exposed to assistive
+     * technology as `role="img"` with this label; when omitted, the dot is purely
+     * decorative (`aria-hidden`) on the assumption that adjacent text conveys the
+     * status. Use this only when the colour/pulse is the sole carrier of meaning.
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    /**
+     * @protected Dot size expressed in `rem` for the `--mlv-status-indicator-size`
+     * custom property (keeps the value scalable rather than binding raw px).
+     */
+    protected readonly _sizeVar: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvStatusIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvStatusIndicator, "mlv-status-indicator", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "pulse": { "alias": "pulse"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/status-indicator/malva-ui-core-status-indicator.d.ts

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

package/stepper/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/stepper/stepper';
+export * from './lib/stepper/step';
+export * from './lib/stepper/stepper-token';
+export * from './lib/stepper/stepper.types';

package/stepper/lib/stepper/step-header.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef } from '@angular/core';
+import type { FocusableOption } from '@angular/cdk/a11y';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/**
+ * `[mlvStepHeader]` — applied to each step-header trigger element inside
+ * `mlv-stepper`. Implements {@link FocusableOption} so the parent
+ * `MlvStepper` can drive arrow-key navigation and roving tabindex via a
+ * CDK `FocusKeyManager`.
+ *
+ * @internal Not part of the public API — an implementation detail of the stepper.
+ */
+export declare class MlvStepHeader implements FocusableOption {
+    /** @internal Host element reference, used for focus + focused-element lookup. */
+    readonly elementRef: ElementRef<any>;
+    /**
+     * Whether this step header is non-interactive (e.g. a not-yet-reachable step
+     * in linear mode). Disabled headers are skipped by the FocusKeyManager and
+     * removed from the roving tab order.
+     */
+    readonly isDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @internal Roving tabindex value managed by the parent FocusKeyManager.
+     * `0` for the currently focused header, `-1` for all others. Bound to the
+     * host element's `tabindex` attribute in the stepper template.
+     */
+    readonly tabIndex: import("@angular/core").WritableSignal<number>;
+    /** FocusableOption — whether this header is skipped by the FocusKeyManager. */
+    get disabled(): boolean;
+    /** FocusableOption — programmatically focuses this step header. */
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvStepHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvStepHeader, "[mlvStepHeader]", ["mlvStepHeader"], { "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/stepper/lib/stepper/step.d.ts

@@ -0,0 +1,51 @@
+import type { TemplateRef } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvStepState } from './stepper.types';
+import * as i0 from "@angular/core";
+/**
+ * `mlv-step` — a step definition component. Declare steps as children of
+ * `mlv-stepper`. The stepper renders the headers and content panels itself;
+ * the projected content of each `<mlv-step>` is shown in the active panel.
+ */
+export declare class MlvStep {
+    /**
+     * Step label displayed in the step header.
+     */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /**
+     * Optional descriptive sub-label shown below the main label.
+     */
+    readonly description: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Explicit state override. When provided, takes precedence over the derived
+     * state from the stepper's `activeIndex`.
+     */
+    readonly state: import("@angular/core").InputSignal<MlvStepState | undefined>;
+    /**
+     * When `true`, this step is optional and can be skipped even in linear mode.
+     */
+    readonly optional: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, this step represents an alternative/deviative path.
+     * The connector after this step is rendered with a dashed warning-color border,
+     * and the indicator receives a visual warning badge overlay.
+     */
+    readonly deviative: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, marks this deviative step's deviation as resolved.
+     * The connector AFTER this step reverts to the normal (solid, neutral) style
+     * instead of dashed/warning. Has no visual effect unless `deviative` is also true.
+     * When the user returns to this step and `deviationResolved` becomes false again,
+     * the connector reverts to the dashed/warning style.
+     */
+    readonly deviationResolved: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * 0-based index assigned by the parent `MlvStepper` after content init.
+     * @internal
+     */
+    _index: number;
+    /** @internal Template reference holding this step's projected content. */
+    readonly contentTpl: import("@angular/core").Signal<TemplateRef<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvStep, "mlv-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "deviative": { "alias": "deviative"; "required": false; "isSignal": true; }; "deviationResolved": { "alias": "deviationResolved"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/stepper/lib/stepper/stepper-token.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+import type { MlvStepperOrientation } from './stepper.types';
+/** Interface exposed by the stepper container to child step components. */
+export interface MlvStepperAccessor {
+    /** Current active step index (0-based). */
+    readonly activeIndex: () => number;
+    /** Orientation of the stepper layout. */
+    readonly orientation: () => MlvStepperOrientation;
+    /** Called by a step when the user clicks on its header to navigate. */
+    selectStep(index: number): void;
+}
+/** Injection token for `MlvStepper` → `MlvStep` communication. */
+export declare const MLV_STEPPER: InjectionToken<MlvStepperAccessor>;

package/stepper/lib/stepper/stepper.d.ts

@@ -0,0 +1,98 @@
+import type { AfterContentInit } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvStep } from './step';
+import type { MlvStepState, MlvStepperOrientation } from './stepper.types';
+import * as i0 from "@angular/core";
+/**
+ * `mlv-stepper` — a multi-step workflow container.
+ *
+ * Usage:
+ * ```html
+ * <mlv-stepper>
+ *   <mlv-step label="Account">...</mlv-step>
+ *   <mlv-step label="Profile">...</mlv-step>
+ *   <mlv-step label="Review">...</mlv-step>
+ * </mlv-stepper>
+ * ```
+ */
+export declare class MlvStepper implements AfterContentInit {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvStepperI18n>;
+    /** @private Used to tear down the FocusKeyManager. */
+    private readonly _destroyRef;
+    /**
+     * MlvLayout orientation of the stepper.
+     * `'horizontal'` renders step headers side-by-side with a connector line.
+     * `'vertical'` stacks each step header and its content in a column.
+     */
+    readonly orientation: import("@angular/core").InputSignal<MlvStepperOrientation>;
+    /**
+     * When `true`, users must complete each step in order before proceeding.
+     * Only completed and the next pending step are clickable.
+     */
+    readonly linear: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Zero-based index of the initially active step.
+     */
+    readonly initialIndex: import("@angular/core").InputSignal<number>;
+    /**
+     * Accessible label for the stepper container announced by screen readers.
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Emits the new zero-based active step index after navigation.
+     */
+    readonly activeIndexChange: import("@angular/core").OutputEmitterRef<number>;
+    /** @private Zero-based index of the currently active step (internal signal). */
+    readonly activeIndex: import("@angular/core").WritableSignal<number>;
+    /** @private Projected step definition components. */
+    private readonly _steps;
+    /** @protected Iterable step array for the template. */
+    protected readonly _stepList: import("@angular/core").Signal<readonly MlvStep[]>;
+    /** @protected CSS class list applied to the host. */
+    protected readonly _hostClasses: import("@angular/core").Signal<string>;
+    /** @private Step-header trigger directives rendered in the current orientation. */
+    private readonly _headers;
+    /** @private Drives arrow-key navigation + roving tabindex over the step headers. */
+    private _keyManager;
+    constructor();
+    ngAfterContentInit(): void;
+    /**
+     * @protected Keydown handler on the step-header tablist. Delegates arrow /
+     * Home / End navigation to the FocusKeyManager (roving tabindex + focus),
+     * leaving Enter/Space activation to the individual headers.
+     */
+    protected _onHeaderKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Resolve the index of the step header containing `target`, or `-1`.
+     */
+    private _focusedHeaderIndex;
+    /**
+     * Navigate to the next step (no-op if already at the last step).
+     */
+    next(): void;
+    /**
+     * Navigate to the previous step (no-op if already at the first step).
+     */
+    previous(): void;
+    /**
+     * Navigate directly to the step at `index`.
+     * In linear mode, forward navigation beyond the active step is blocked.
+     */
+    selectStep(index: number): void;
+    /** @protected Resolve the effective state for a given step. */
+    protected _stateFor(step: MlvStep): MlvStepState;
+    /** @protected Returns `true` if a step header is clickable. */
+    protected _isClickable(step: MlvStep): boolean;
+    /** @private Emit and update the active index. */
+    private _navigate;
+    /** @private Assign sequential indices to child step components. */
+    private _assignIndices;
+    /**
+     * @private Reflect the FocusKeyManager's active item into the roving
+     * tabindex: the active header is tabbable (`0`), all others are `-1`.
+     */
+    private _syncTabIndices;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvStepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvStepper, "mlv-stepper", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "initialIndex": { "alias": "initialIndex"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "activeIndexChange": "activeIndexChange"; }, ["_steps"], never, true, never>;
+}

package/stepper/lib/stepper/stepper.types.d.ts

@@ -0,0 +1,4 @@
+/** State of a single step. */
+export type MlvStepState = 'pending' | 'active' | 'completed' | 'error';
+/** MlvLayout orientation of the stepper. */
+export type MlvStepperOrientation = 'horizontal' | 'vertical';

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

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