@malva-ui/core 0.1.12 → 0.1.14

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

@@ -0,0 +1,73 @@
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvTone } from '@malva-ui/cdk/utils';
+
+/**
+ * Semantic tone for the progress component. Extends the shared {@link MlvTone}
+ * vocabulary (`'info' | 'success' | 'warning' | 'danger'`) with a neutral
+ * `'default'`.
+ */
+type MlvProgressTone = MlvTone | 'default';
+/** Visual shape of the progress component. */
+type MlvProgressShape = 'bar' | 'circle';
+/** Size variant of the progress component. */
+type MlvProgressSize = 's' | 'm' | 'l';
+/** SVG dimensions used for the circle variant. */
+interface CircleDimensions {
+    /** SVG viewBox string. */
+    viewBox: string;
+    /** Circle center X/Y coordinate. */
+    center: number;
+    /** Circle radius. */
+    radius: number;
+    /** Full stroke circumference. */
+    circumference: number;
+    /** Stroke width in viewBox units. */
+    strokeWidth: number;
+}
+declare class MlvProgress {
+    /** Visual shape variant — `'bar'` for a horizontal track, `'circle'` for an SVG ring. */
+    readonly shape: _angular_core.InputSignal<MlvProgressShape>;
+    /**
+     * Current progress value between 0 and 100.
+     * Clamped to the `[0, 100]` range internally.
+     */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Size variant controlling track height (bar) or diameter (circle). */
+    readonly size: _angular_core.InputSignal<MlvProgressSize>;
+    /** Semantic tone applied to the fill element. */
+    readonly tone: _angular_core.InputSignal<MlvProgressTone>;
+    /**
+     * When `true`, displays the current value as a percentage text.
+     * Bar: appears above the track (right-aligned).
+     * Circle: appears centred inside the ring.
+     */
+    readonly showPercentage: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Custom aria-label override. Falls back to the i18n-provided label. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvProgressI18n>;
+    /** @protected Resolved aria-label: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedAriaLabel: _angular_core.Signal<string>;
+    /** @protected Progress clamped to [0, 100]. */
+    protected readonly _clampedValue: _angular_core.Signal<number>;
+    /** @protected Formatted percentage text. */
+    protected readonly _percentageText: _angular_core.Signal<string>;
+    /**
+     * @protected Delays enabling the CSS fill transition by one tick so the browser
+     * has a defined starting state before the transition begins.
+     */
+    protected readonly _progressVisible: _angular_core.Signal<boolean | undefined>;
+    /** @protected Computed circle SVG dimensions based on the size input. */
+    protected readonly _circleDimensions: _angular_core.Signal<CircleDimensions>;
+    /** @protected The stroke-dashoffset for the circle fill, derived from clamped value. */
+    protected readonly _strokeDashoffset: _angular_core.Signal<number>;
+    /** @protected Host CSS class string. */
+    protected readonly _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvProgress, "mlv-progress", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "showPercentage": { "alias": "showPercentage"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*", "*"], true, never>;
+}
+
+export { MlvProgress };
+export type { MlvProgressShape, MlvProgressSize, MlvProgressTone };

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

@@ -0,0 +1,130 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvSignalFormControlBase, MlvFormState } from '@malva-ui/core/form-utils';
+
+declare class MlvRadio {
+    /** @private Optional parent radio group accessor injected via `RADIO_GROUP`. */
+    private readonly _group;
+    /** @private Host element reference, used to strip the moved ARIA attributes. */
+    private readonly _elementRef;
+    /** @private Renderer used to imperatively remove host ARIA attributes. */
+    private readonly _renderer;
+    /**
+     * @private The `aria-label` a consumer placed directly on the `<mlv-radio>`
+     * host, captured before host bindings run. The host is role-less, so ARIA
+     * prohibits an `aria-label` there (axe `aria-prohibited-attr`); it is moved to
+     * the inner `<input type="radio">` instead (see the constructor).
+     */
+    private readonly _hostAriaLabel;
+    /**
+     * @private The `aria-labelledby` a consumer placed directly on the
+     * `<mlv-radio>` host, captured before host bindings run. Moved to the inner
+     * input for the same reason as {@link _hostAriaLabel}.
+     */
+    private readonly _hostAriaLabelledBy;
+    /**
+     * Accessible name applied to the inner native input (`aria-label`). Use this
+     * input (not a host `[attr.aria-label]` binding) when the label is dynamic —
+     * the role-less host must not carry ARIA naming attributes
+     * (axe `aria-prohibited-attr`). A static host `aria-label` attribute is also
+     * supported and forwarded automatically (see the constructor); this input
+     * takes precedence when both are present.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Id reference(s) naming the inner native input (`aria-labelledby`). Same
+     * rationale and precedence as {@link ariaLabel}.
+     */
+    readonly ariaLabelledBy: _angular_core.InputSignal<string | undefined>;
+    /**
+     * @internal The accessible name forwarded onto the native input, sourced from a
+     * host `aria-label`. `null` when the consumer supplied none, so no empty
+     * `aria-label` is emitted on the input (and any group-provided naming is left
+     * untouched).
+     */
+    readonly _ariaLabel: _angular_core.WritableSignal<string | null>;
+    /**
+     * @internal The `aria-labelledby` forwarded onto the native input, sourced from
+     * a host `aria-labelledby`. `null` when the consumer supplied none.
+     */
+    readonly _ariaLabelledBy: _angular_core.WritableSignal<string | null>;
+    /**
+     * @internal The final `aria-label` for the native input: the `ariaLabel` input
+     * wins over a captured static host attribute; `null` emits no attribute.
+     */
+    readonly _resolvedAriaLabel: _angular_core.Signal<string | null>;
+    /**
+     * @internal The final `aria-labelledby` for the native input, with the same
+     * precedence as {@link _resolvedAriaLabel}.
+     */
+    readonly _resolvedAriaLabelledBy: _angular_core.Signal<string | null>;
+    constructor();
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly name: _angular_core.WritableSignal<string>;
+    /**
+     * Roving tabindex applied to the native `<input type="radio">` — the single
+     * focus target. `0` for the tabbable radio, `-1` for the rest. Managed by
+     * `MlvRadioGroup`.
+     */
+    readonly tabIndex: _angular_core.WritableSignal<number>;
+    /**
+     * @private Reference to the visually-hidden native radio input, which is the
+     * focus target (kept in the a11y tree via the clip-path pattern so native
+     * radio semantics — Space selection, grouping — are preserved).
+     */
+    private readonly _nativeInput;
+    /**
+     * Moves focus to the native radio input. Satisfies CDK `FocusableOption` so
+     * the group's `FocusKeyManager` focuses the input rather than the host.
+     */
+    focus(): void;
+    /** @internal Notifies the parent group when the native input gains focus. */
+    onFocus(): void;
+    /** @internal Handles native selection (click, Space, native arrow keys). */
+    onSelect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvRadio, "mlv-radio", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface MlvRadioGroupAccessor {
+    selectRadio(radio: MlvRadio): void;
+    onChildFocus(radio: MlvRadio): void;
+}
+
+/**
+ * Visual/validation state of the group. Structurally identical to
+ * {@link MlvFormState}; retained as a public alias for backwards compatibility.
+ */
+type MlvRadioGroupState = MlvFormState;
+declare class MlvRadioGroup extends MlvSignalFormControlBase<unknown> implements MlvRadioGroupAccessor {
+    /** Two-way bindable selected value of the group. */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    /** Shared `name` applied to the native radio inputs in the group. */
+    readonly name: _angular_core.InputSignalWithTransform<string, string | undefined>;
+    readonly radios: _angular_core.Signal<readonly MlvRadio[]>;
+    /** @private FocusKeyManager driving roving focus + arrow-key navigation across the radios. */
+    private _keyManager;
+    /** @private Normalizes horizontal radio navigation for RTL layouts. */
+    private readonly _rtlService;
+    constructor();
+    onChildFocus(radio: MlvRadio): void;
+    /**
+     * @protected Host keydown handler. Handles all four arrow keys for WAI-ARIA
+     * radiogroup semantics, moving focus + selection via the FocusKeyManager.
+     */
+    _onKeydown(event: KeyboardEvent): void;
+    selectRadio(radio: MlvRadio): void;
+    /** Whether the control holds a clearable value — A radio value is selected. */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /** @private Syncs each radio's checked state to the current group value and refreshes tab indices. */
+    private _updateSelection;
+    /** @private Applies the roving tabindex: only the checked radio (or first when none checked) is tabbable. */
+    private _updateTabIndices;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvRadioGroup, "mlv-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], ["*"], true, never>;
+}
+
+export { MlvRadio, MlvRadioGroup };
+export type { MlvRadioGroupState };

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

@@ -0,0 +1,115 @@
+import * as _angular_core from '@angular/core';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { MlvSignalFormControlBase, MlvFormControl } from '@malva-ui/core/form-utils';
+
+/**
+ * Star rating component with half-star precision and read-only mode.
+ *
+ * Extends {@link MlvSignalFormControlBase}, inheriting the shared `disabled`,
+ * `readonly`, `state`, `id`, `label`, `hint` and `message` inputs plus the
+ * signal-forms field contract.
+ *
+ * - Hover preview highlights stars up to the cursor.
+ * - Half-star precision via clip-path technique when `step="0.5"`.
+ * - Keyboard: ArrowRight/ArrowLeft step up/down, Home for min, End for max.
+ * - Integrates with signal, reactive, and template-driven Angular forms.
+ *
+ * @example Basic
+ * ```html
+ * <mlv-rating [max]="5" [(ngModel)]="rating" />
+ * ```
+ *
+ * @example Half-star precision
+ * ```html
+ * <mlv-rating [step]="0.5" [formField]="ratingForm.score" />
+ * ```
+ *
+ * @example Read-only display
+ * ```html
+ * <mlv-rating [value]="4.5" [readonly]="true" />
+ * ```
+ */
+declare class MlvRating extends MlvSignalFormControlBase<number> implements MlvFormControl {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvRatingI18n>;
+    /** @private Resolver for ICU parameterized i18n strings. */
+    private readonly _resolver;
+    private readonly _rtlService;
+    /**
+     * @private Effective direction of this rating, tracking the global direction
+     * and any `[dir]` scope above the host. Mirrors half-star hit testing.
+     */
+    private readonly _direction;
+    /**
+     * @private Whether the pointer is over the leading (lower-value) half of a
+     * star. `offsetX` is always measured from the physical left edge, so RTL —
+     * where the leading half is the right one — has to mirror it.
+     */
+    private _isLeadingHalf;
+    /**
+     * Total number of stars.
+     * @default 5
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number, string | number | null | undefined>;
+    /**
+     * Step increment — `1` for whole stars, `0.5` for half-star precision.
+     * @default 1
+     */
+    readonly step: _angular_core.InputSignalWithTransform<1 | 0.5, number | null | undefined>;
+    /**
+     * The committed rating — the signal-forms `FormValueControl` model. Kept in
+     * sync by `[formField]`, `[formControl]`, and `ngModel` bindings.
+     */
+    readonly value: _angular_core.ModelSignal<number>;
+    /** Tracks the hover preview value (0 = not hovering). */
+    protected readonly _hoverValue: _angular_core.WritableSignal<number>;
+    /** The value visually displayed — hover preview takes precedence. */
+    protected readonly _displayValue: _angular_core.Signal<number>;
+    /** Indices `[0 … max-1]` for `@for` iteration. */
+    protected readonly _indices: _angular_core.Signal<number[]>;
+    /**
+     * The 0-based index of the star that is in the tab order (roving tabindex).
+     * The star covering the current value is tabbable; when no value is set the
+     * first star is. All other stars are removed from the tab order so the rating
+     * is a single tab stop, with Arrow keys moving between values.
+     */
+    protected readonly _activeIndex: _angular_core.Signal<number>;
+    /** Whether the control holds a clearable value — A non-zero rating is set. */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /**
+     * Returns the percentage of star `starIndex` (1-indexed) that should be filled.
+     * 100 = full, 50 = half, 0 = empty.
+     */
+    protected _getFillPercent(starIndex: number): number;
+    /**
+     * Returns the CSS `clip-path` value for the filled star overlay.
+     * `inset(0 {remainder}% 0 0)` clips the right side.
+     */
+    protected _clipPath(starIndex: number): string;
+    /**
+     * @internal Resolves the per-star aria-label, e.g. "Rate 3 out of 5".
+     * @param starIndex 1-based star number.
+     */
+    protected _rateLabel(starIndex: number): string;
+    /**
+     * @internal Roving tabindex for star `index` (0-based): `0` for the active
+     * star, `-1` for the rest. Always `-1` when read-only or disabled.
+     */
+    protected _starTabIndex(index: number): number;
+    /** @internal */
+    protected _onStarMouseMove(starIndex: number, event: MouseEvent): void;
+    /** @internal */
+    protected _onStarClick(starIndex: number, event: MouseEvent): void;
+    /** @internal */
+    protected _onHostMouseLeave(): void;
+    /** @internal */
+    protected _onHostKeydown(event: KeyboardEvent): void;
+    /** @internal */
+    protected _onStarFocus(starIndex: number): void;
+    /** @internal */
+    protected _onStarBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvRating, "mlv-rating", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+export { MlvRating };

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

@@ -0,0 +1,203 @@
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/** Controls which scroll axes render a custom scrollbar. */
+type MlvScrollbarOrientation = 'vertical' | 'horizontal' | 'both';
+/**
+ * Custom scrollbar component that hides the native browser scrollbar and
+ * renders a minimalistic custom one in accordance with the Malva UI theme.
+ *
+ * Wrap any scrollable content in `<mlv-scrollbar>`. The component must have
+ * a defined height (set via CSS or via flex/grid sizing from a parent).
+ * Native scroll behaviour is **never intercepted** — the viewport scrolls
+ * exactly as if the component were not present. The custom thumb is a pure
+ * visual overlay that stays in sync with the viewport's scroll position.
+ *
+ * @example Vertical (default)
+ * ```html
+ * <mlv-scrollbar style="height: 12rem">
+ *   <p>Long content…</p>
+ * </mlv-scrollbar>
+ * ```
+ *
+ * @example Horizontal
+ * ```html
+ * <mlv-scrollbar orientation="horizontal" style="width: 20rem">
+ *   <div style="width: 60rem">Wide content…</div>
+ * </mlv-scrollbar>
+ * ```
+ *
+ * @example Both axes
+ * ```html
+ * <mlv-scrollbar orientation="both" style="height: 12rem; width: 20rem">
+ *   <div style="height: 30rem; width: 60rem">…</div>
+ * </mlv-scrollbar>
+ * ```
+ */
+declare class MlvScrollbar {
+    /**
+     * Which scroll axes to show the custom scrollbar on.
+     * Default: `'vertical'`.
+     */
+    readonly orientation: _angular_core.InputSignal<MlvScrollbarOrientation>;
+    /**
+     * CSS length value for the scrollbar track zone width (vertical) or height
+     * (horizontal). Maps to the `--mlv-sb-size` custom property on the host.
+     * The visible thumb is narrower due to the cross-axis inset (`--mlv-sb-inset`).
+     * Default: `'0.75rem'` (12 px track zone → 4 px visible thumb after 4 px inset each side).
+     */
+    readonly scrollbarSize: _angular_core.InputSignal<string>;
+    /**
+     * When `true`, hides the custom scrollbar tracks and restores the browser's
+     * native scrollbar. Supports attribute syntax: `<mlv-scrollbar disabled>`.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Custom aria-label override for the scrollable viewport region.
+     * Falls back to the i18n-provided label.
+     * Override when the component wraps content with a more specific purpose,
+     * e.g. `ariaLabel="Chat messages"`.
+     *
+     * The label is only written to the DOM while the viewport is itself a tab
+     * stop — see `viewportTabIndex`. A viewport that is not keyboard-reachable
+     * is left as a plain container, because `aria-label` is prohibited on a
+     * role-less element and naming a non-interactive wrapper only adds noise.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Tab index applied to the native scroll viewport.
+     *
+     * The default `0` means **auto**: the viewport is a tab stop only while its
+     * content holds nothing tabbable. A text-only region stays reachable so
+     * keyboard users can scroll it (WCAG 2.1.1), but a region full of form
+     * controls does not add a redundant stop in front of them — which is what
+     * put a focus ring around an entire dialog body on open.
+     *
+     * Any non-zero value is applied verbatim; composite widgets that manage
+     * their own focus pass `-1`.
+     */
+    readonly viewportTabIndex: _angular_core.InputSignal<number>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvScrollbarI18n> | null;
+    /** @protected Resolved aria-label: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedAriaLabel: _angular_core.Signal<string>;
+    /**
+     * @protected Whether the scrolled content currently holds a tabbable element.
+     * Recomputed after render and on every content mutation.
+     */
+    protected readonly _hasTabbableContent: _angular_core.WritableSignal<boolean>;
+    /**
+     * @protected Tab index actually written to the viewport.
+     *
+     * `0` is treated as "auto" and collapses to `-1` once the content itself is
+     * keyboard-reachable; every other value passes through unchanged.
+     */
+    protected readonly _effectiveViewportTabIndex: _angular_core.Signal<number>;
+    /**
+     * @protected Whether the viewport is itself reachable by keyboard.
+     *
+     * Only a viewport that is a tab stop is a control the user can land on, and
+     * therefore the only case in which the region has to introduce and name
+     * itself (WCAG 4.1.2).
+     */
+    protected readonly _isViewportFocusable: _angular_core.Signal<boolean>;
+    /**
+     * @protected ARIA role written to the viewport, or `null` for none.
+     *
+     * `aria-label` is prohibited on an element with no role (implicit
+     * `generic`), so the label was previously discarded by assistive technology.
+     * A focusable scroll container is exposed as `group` rather than the
+     * landmark `region`, so that wrapping content in `mlv-scrollbar` never
+     * injects a landmark — nor a repeated "Scrollable region" landmark name —
+     * into the page. When the viewport is not a tab stop it stays role-less and
+     * unnamed: the projected content owns its own semantics.
+     */
+    protected readonly _viewportRole: _angular_core.Signal<"group" | null>;
+    /**
+     * @protected The label actually written to the viewport, or `null`.
+     *
+     * Mirrors `_viewportRole` so the name is never emitted without a role that
+     * permits it.
+     */
+    protected readonly _viewportAriaLabel: _angular_core.Signal<string | null>;
+    /** @protected Whether the vertical track should be rendered. */
+    protected readonly _showVertical: _angular_core.Signal<boolean>;
+    /** @protected Whether the horizontal track should be rendered. */
+    protected readonly _showHorizontal: _angular_core.Signal<boolean>;
+    /** @protected True when scrollHeight > clientHeight (vertical overflow present). */
+    protected readonly _hasVerticalOverflow: _angular_core.WritableSignal<boolean>;
+    /** @protected True when scrollWidth > clientWidth (horizontal overflow present). */
+    protected readonly _hasHorizontalOverflow: _angular_core.WritableSignal<boolean>;
+    /** @protected Vertical thumb top offset in pixels (set as inline style). */
+    protected readonly _thumbTop: _angular_core.WritableSignal<number>;
+    /** @protected Vertical thumb height in pixels (set as inline style). */
+    protected readonly _thumbHeight: _angular_core.WritableSignal<number>;
+    /** @protected Horizontal thumb left offset in pixels (set as inline style). */
+    protected readonly _thumbLeft: _angular_core.WritableSignal<number>;
+    /** @protected Horizontal thumb width in pixels (set as inline style). */
+    protected readonly _thumbWidth: _angular_core.WritableSignal<number>;
+    /** @protected True while the user is actively dragging a thumb. Adds `--dragging` modifier. */
+    protected readonly _isDragging: _angular_core.WritableSignal<boolean>;
+    /** @protected True while scroll events are firing. Cleared after 150 ms idle. Adds `--scrolling` modifier. */
+    protected readonly _isScrolling: _angular_core.WritableSignal<boolean>;
+    /** @private Reference to the inner scrollable viewport element. */
+    private readonly _viewport;
+    /**
+     * The native scrollable viewport element.
+     * Lets wrapping components (e.g. `main[mlvPage]`) observe scroll position
+     * without reaching into the component's private DOM.
+     */
+    get viewportElement(): HTMLElement;
+    /** @private Reference to the vertical track element. */
+    private readonly _trackV;
+    /** @private Reference to the horizontal track element. */
+    private readonly _trackH;
+    /** @private Minimum rendered thumb length in pixels — prevents thumb from becoming unclickable. */
+    private readonly _minThumbSize;
+    /** @private Native ResizeObserver watching viewport and content size. */
+    private _resizeObserver;
+    /** @private Native MutationObserver keeping `_hasTabbableContent` in sync with projected content. */
+    private _contentObserver;
+    /** @private CDK checker used to decide whether projected content is keyboard-reachable. */
+    private readonly _interactivityChecker;
+    /** @private Timeout ID for clearing the `--scrolling` modifier after idle. */
+    private _scrollTimeout;
+    /** @private DestroyRef used to clean up the ResizeObserver, timers, and drag listeners. */
+    private readonly _destroyRef;
+    /** @private Renderer2 used so DOM listeners are SSR-safe and unsubscribable. */
+    private readonly _renderer;
+    constructor();
+    /**
+     * @private Re-reads whether the projected content contains a tab stop.
+     *
+     * Drives `_effectiveViewportTabIndex`: a scroll region only needs to be a tab
+     * stop of its own when nothing inside it already is (WCAG 2.1.1). Keeping it
+     * unconditionally tabbable put a redundant stop — and a focus ring around the
+     * whole region — in front of every dialog body's form controls.
+     */
+    private _updateTabbableContent;
+    /** @protected Handles scroll events on the viewport. Updates thumb positions and `--scrolling` state. */
+    protected _onScroll(): void;
+    /**
+     * @protected Handles `pointerdown` on a scrollbar thumb.
+     * Captures the pointer and translates subsequent `pointermove` deltas into
+     * viewport scroll offsets. Releases on `pointerup` or `pointercancel`.
+     */
+    protected _onThumbPointerDown(event: PointerEvent, axis: 'vertical' | 'horizontal'): void;
+    /**
+     * @private Recalculates overflow detection and thumb geometry.
+     * Called after first render, on ResizeObserver notifications, and on scroll.
+     */
+    private _updateGeometry;
+    /**
+     * @private Recomputes thumb position and size signals from the current viewport
+     * scroll state. Fast path — called on every scroll event.
+     */
+    private _updateThumbPositions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvScrollbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvScrollbar, "mlv-scrollbar", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "scrollbarSize": { "alias": "scrollbarSize"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "viewportTabIndex": { "alias": "viewportTabIndex"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { MlvScrollbar };
+export type { MlvScrollbarOrientation };