@vadem/ui 0.0.0-stage → 0.0.1

package/types/vadem-ui-menu.d.ts

@@ -0,0 +1,132 @@
+import * as i0 from "@angular/core";
+/** Menu panel: a `popover="auto"` with `role="menu"`. Open it with `vdMenuTrigger`. */
+export declare class VdMenu {
+  readonly id: string;
+  readonly el: HTMLElement;
+  readonly labelledBy: import("@angular/core").WritableSignal<string | null>;
+  items(): HTMLElement[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMenu, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdMenu, "[vdMenu]", ["vdMenu"], {}, {}, never, never, true, never>;
+}
+/** Opens a `vdMenu`. Use on a button (works with `vdButton`). Spec: specs/menu.md */
+export declare class VdMenuTrigger {
+  readonly vdMenuTrigger: import("@angular/core").InputSignal<VdMenu>;
+  protected readonly open: import("@angular/core").WritableSignal<boolean>;
+  private readonly el;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMenuTrigger, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdMenuTrigger, "button[vdMenuTrigger]", never, {
+    "vdMenuTrigger": {
+      "alias": "vdMenuTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+type VdMenuItemVariant = 'default' | 'danger';
+export declare class VdMenuItem {
+  readonly variant: import("@angular/core").InputSignal<VdMenuItemVariant>;
+  /** Disabled items stay in the menu (discoverable) but are skipped and inert. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly isButton: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMenuItem, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdMenuItem, "button[vdMenuItem], a[vdMenuItem]", never, {
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class VdMenuSeparator {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMenuSeparator, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdMenuSeparator, "[vdMenuSeparator]", never, {}, {}, never, never, true, never>;
+}
+/** Group heading inside a menu (mono eyebrow). Presentational. */
+export declare class VdMenuLabel {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMenuLabel, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdMenuLabel, "[vdMenuLabel]", never, {}, {}, never, never, true, never>;
+}
+export declare const VD_MENU: readonly [typeof VdMenu, typeof VdMenuTrigger, typeof VdMenuItem, typeof VdMenuSeparator, typeof VdMenuLabel];
+interface VdMenuControllerOptions {
+  /** Items in DOM order (role="menuitem", including disabled ones). */
+  items(): HTMLElement[];
+  onOpenChange?(open: boolean): void;
+  /** Where focus returns on close; defaults to the trigger (context menus return to the opener). */
+  returnFocusTo?(): HTMLElement | null;
+}
+export declare class VdMenuController {
+  private readonly trigger;
+  private readonly menu;
+  private readonly options;
+  private readonly typeahead;
+  private returnFocus;
+  /** Light dismiss closes on pointerdown over the trigger; the click must not reopen. */
+  private wasOpen;
+  constructor(trigger: HTMLElement, menu: HTMLElement, options: VdMenuControllerOptions);
+  get isOpen(): boolean;
+  open(focus?: 'first' | 'last'): void;
+  close(returnFocus: boolean): void;
+  destroy(): void;
+  private enabledItems;
+  private readonly onTriggerPointerDown;
+  private readonly onTriggerClick;
+  private readonly onTriggerKeydown;
+  private readonly onMenuKeydown;
+  private readonly onMenuClick;
+  /** Pointer and keyboard share one "current" item: hovering focuses it. */
+  private readonly onPointerMove;
+  private readonly onToggle;
+}
+/**
+ * Opens a `vdMenu` at the pointer on right-click / long-press, or at the focused element on
+ * the ContextMenu key and Shift+F10. Spec: specs/menu.md
+ */
+export declare class VdContextMenu {
+  readonly vdContextMenu: import("@angular/core").InputSignal<VdMenu>;
+  /** Accessible name of the menu while this region opened it. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Fires before the menu opens, so the consumer can point it at this region's item. */
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+  }, "label">>;
+  private readonly el;
+  private readonly doc;
+  private entry;
+  private pressTimer;
+  constructor();
+  protected onContextMenu(event: MouseEvent): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  protected onPointerDown(event: PointerEvent): void;
+  private openAt;
+  /**
+   * Puts the zero-size anchor at viewport point (x, y). An ancestor with a transform, filter or
+   * container query becomes the fixed containing block, so the first guess is measured and
+   * corrected by the difference. Insets stay logical: in RTL inline-start grows leftwards.
+   */
+  private place;
+  /** Focus returns to the nearest focusable element of this region, or the region itself. */
+  private focusable;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdContextMenu, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdContextMenu, "[vdContextMenu]", never, {
+    "vdContextMenu": {
+      "alias": "vdContextMenu";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "opened": "opened";
+  }, never, never, true, never>;
+}
+export type { VdMenuControllerOptions, VdMenuItemVariant };

package/types/vadem-ui-navigation-list.d.ts

@@ -0,0 +1,28 @@
+import * as i0 from "@angular/core";
+/** Native navigation landmark; applications supply groups, links and current state. */
+export declare class VdNavigationList {
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+  }, "label">>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdNavigationList, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdNavigationList, "nav[vdNavigationList]", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Keeps href, router integration, keyboard and modified-click behavior native. */
+export declare class VdNavigationLink {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdNavigationLink, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdNavigationLink, "a[vdNavigationLink]", never, {}, {}, never, never, true, never>;
+}
+/** Preserves the consumer's heading level and section labelling. */
+export declare class VdNavigationLabel {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdNavigationLabel, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdNavigationLabel, "[vdNavigationLabel]", never, {}, {}, never, never, true, never>;
+}
+export declare const VD_NAVIGATION_LIST: readonly [typeof VdNavigationList, typeof VdNavigationLink, typeof VdNavigationLabel];

package/types/vadem-ui-number-input.d.ts

@@ -0,0 +1,39 @@
+import { VdInput } from "@vadem/ui/input";
+import * as i0 from "@angular/core";
+/** Numeric native Input: the platform/forms accessor remains the source of value. */
+export declare class VdNumberInput extends VdInput {
+  private readonly el;
+  private readonly snapshot;
+  readonly locked: import("@angular/core").Signal<boolean>;
+  readonly canDecrease: import("@angular/core").Signal<boolean>;
+  readonly canIncrease: import("@angular/core").Signal<boolean>;
+  constructor();
+  refresh(): void;
+  step(direction: -1 | 1): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdNumberInput, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdNumberInput, "input[type=number][vdNumberInput]", ["vdNumberInput"], {}, {}, never, never, true, never>;
+}
+export declare class VdNumberInputGroup {
+  readonly decreaseLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly increaseLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    decreaseLabel: string;
+    increaseLabel: string;
+  }, "decreaseLabel" | "increaseLabel">>;
+  protected readonly control: import("@angular/core").Signal<VdNumberInput | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdNumberInputGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdNumberInputGroup, "vd-number-input", never, {
+    "decreaseLabel": {
+      "alias": "decreaseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "increaseLabel": {
+      "alias": "increaseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["control"], ["input[vdNumberInput]"], true, never>;
+}
+export declare const VD_NUMBER_INPUT: readonly [typeof VdNumberInputGroup, typeof VdNumberInput];

package/types/vadem-ui-otp-input.d.ts

@@ -0,0 +1,15 @@
+import { VdInput } from "@vadem/ui/input";
+import * as i0 from "@angular/core";
+/** One native code field: editing, clipboard, autofill and value accessors remain native. */
+export declare class VdOtpInput extends VdInput {
+  readonly length: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  protected readonly codeLength: import("@angular/core").Signal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdOtpInput, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdOtpInput, "input[vdOtpInput]", never, {
+    "length": {
+      "alias": "length";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/vadem-ui-pagination.d.ts

@@ -0,0 +1,96 @@
+import * as i0 from "@angular/core";
+type VdPaginationSize = 'sm' | 'md';
+/**
+ * Page navigation for paged lists and tables. Buttons (not links): the consumer loads the page.
+ * Spec: specs/pagination.md
+ */
+export declare class VdPagination {
+  /** Current page, 1-based (two-way). */
+  readonly page: import("@angular/core").ModelSignal<number>;
+  readonly pageCount: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly size: import("@angular/core").InputSignal<VdPaginationSize>;
+  /** Pages shown on each side of the current one. */
+  readonly siblings: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** "3 / 12" instead of page buttons (narrow spaces). */
+  readonly compact: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Landmark name; name each pagination on a page differently. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly previousLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly nextLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly pageLabel: import("@angular/core").InputSignal<((page: number) => string) | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    previousLabel: string;
+    nextLabel: string;
+    pageLabel: (page: number) => string;
+  }, "label" | "previousLabel" | "nextLabel" | "pageLabel">>;
+  protected readonly current: import("@angular/core").Signal<number>;
+  protected readonly isFirst: import("@angular/core").Signal<boolean>;
+  protected readonly isLast: import("@angular/core").Signal<boolean>;
+  protected readonly items: import("@angular/core").Signal<import("@vadem/ui/pagination").VdPageItem[]>;
+  /** Native focus scrolling can leave a partially visible button clipped. */
+  protected revealFocused(event: FocusEvent): void;
+  /** Disabled steps use aria-disabled (they keep focus at the edges), so guard here. */
+  protected go(page: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdPagination, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdPagination, "vd-pagination", never, {
+    "page": {
+      "alias": "page";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageCount": {
+      "alias": "pageCount";
+      "required": true;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "siblings": {
+      "alias": "siblings";
+      "required": false;
+      "isSignal": true;
+    };
+    "compact": {
+      "alias": "compact";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "previousLabel": {
+      "alias": "previousLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nextLabel": {
+      "alias": "nextLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageLabel": {
+      "alias": "pageLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "page": "pageChange";
+  }, never, never, true, never>;
+}
+type VdPageItem = number | 'ellipsis';
+/**
+ * Page items to render: first/last `boundaries` pages, `siblings` around the current page,
+ * and 'ellipsis' for gaps. The length stays constant while paging (no jumping layout), and an
+ * ellipsis never hides a single page (that page is shown instead).
+ *
+ * vdPageRange(6, 12) -> [1, 'ellipsis', 5, 6, 7, 'ellipsis', 12]
+ */
+export declare function vdPageRange(page: number, count: number, siblings?: number, boundaries?: number): VdPageItem[];
+export type { VdPageItem, VdPaginationSize };

package/types/vadem-ui-password-input.d.ts

@@ -0,0 +1,36 @@
+import { VdInput } from "@vadem/ui/input";
+import * as i0 from "@angular/core";
+/** Native password value and forms accessor remain on the input. This directive owns type. */
+export declare class VdPasswordInput extends VdInput {
+  readonly element: HTMLInputElement;
+  private readonly document;
+  private readonly visible;
+  readonly revealed: import("@angular/core").Signal<boolean>;
+  private readonly unavailable;
+  readonly locked: import("@angular/core").Signal<boolean>;
+  constructor();
+  /** Pointer activation while editing preserves input focus; keyboard focus stays on the button. */
+  preserveEditingFocus(event: MouseEvent): void;
+  toggle(): void;
+  private setVisible;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdPasswordInput, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdPasswordInput, "input[vdPasswordInput]", ["vdPasswordInput"], {}, {}, never, never, true, never>;
+}
+export declare class VdPasswordInputGroup {
+  /** Stable toggle name; aria-pressed conveys whether revealing is enabled. */
+  readonly revealLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    revealLabel: string;
+  }, "revealLabel">>;
+  protected readonly control: import("@angular/core").Signal<VdPasswordInput | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdPasswordInputGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdPasswordInputGroup, "vd-password-input", never, {
+    "revealLabel": {
+      "alias": "revealLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["control"], ["[slot=start]", "input[vdPasswordInput]"], true, never>;
+}
+export declare const VD_PASSWORD_INPUT: readonly [typeof VdPasswordInputGroup, typeof VdPasswordInput];

package/types/vadem-ui-popover.d.ts

@@ -0,0 +1,48 @@
+import * as i0 from "@angular/core";
+type VdPopoverPlacement = 'bottom' | 'top' | 'start' | 'end';
+/**
+ * Non-modal floating panel with any content (filters, a share form, details): a
+ * `popover="auto"` in the top layer, anchored to its trigger with CSS anchor positioning.
+ * Light dismiss and Escape are native. Give it a name (`aria-label` / `aria-labelledby`).
+ * Spec: specs/popover.md
+ */
+export declare class VdPopover {
+  readonly placement: import("@angular/core").InputSignal<VdPopoverPlacement>;
+  readonly id: string;
+  readonly el: HTMLElement;
+  hide(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdPopover, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdPopover, "[vdPopover]", ["vdPopover"], {
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Toggles a `vdPopover` from a button. On open, focus moves to the popover's `[autofocus]`
+ * element or its first focusable one; closing returns focus to the trigger (the trigger is the
+ * popover's invoker).
+ */
+export declare class VdPopoverTrigger {
+  readonly vdPopoverTrigger: import("@angular/core").InputSignal<VdPopover>;
+  protected readonly open: import("@angular/core").WritableSignal<boolean>;
+  private readonly el;
+  constructor();
+  /** Open state when the press started: light dismiss may already have closed it by click. */
+  private openAtPress;
+  protected rememberState(): void;
+  protected toggle(): void;
+  private focusInside;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdPopoverTrigger, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdPopoverTrigger, "button[vdPopoverTrigger]", never, {
+    "vdPopoverTrigger": {
+      "alias": "vdPopoverTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const VD_POPOVER: readonly [typeof VdPopover, typeof VdPopoverTrigger];
+export type { VdPopoverPlacement };

package/types/vadem-ui-progress.d.ts

@@ -0,0 +1,95 @@
+import * as i0 from "@angular/core";
+type VdProgressSize = 'sm' | 'md';
+type VdProgressVariant = 'accent' | 'success' | 'warning' | 'danger';
+/**
+ * Styles a native `<progress>`: completion of a task. Without `value` it is indeterminate.
+ * Role, value and labelling (`<label for>`, `aria-label`) stay native. Spec: specs/progress.md
+ */
+export declare class VdProgress {
+  readonly size: import("@angular/core").InputSignal<VdProgressSize>;
+  readonly variant: import("@angular/core").InputSignal<VdProgressVariant>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdProgress, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdProgress, "progress[vdProgress]", never, {
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Styles a native `<meter>`: a measurement within a known range (quota, disk, score).
+ * Colors follow the native `low` / `high` / `optimum` regions. Spec: specs/progress.md
+ */
+export declare class VdMeter {
+  readonly size: import("@angular/core").InputSignal<VdProgressSize>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMeter, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdMeter, "meter[vdMeter]", never, {
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+type VdProgressRingSize = 'sm' | 'md' | 'lg';
+/**
+ * Circular progress. Without `value` it is indeterminate (a spinner); with `value` it shows
+ * completion. Spec: specs/progress.md
+ */
+export declare class VdProgressRing {
+  /** Completed amount; leave empty for an indeterminate spinner. */
+  readonly value: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+  readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly size: import("@angular/core").InputSignal<VdProgressRingSize>;
+  readonly variant: import("@angular/core").InputSignal<VdProgressVariant>;
+  /** Percentage in the centre; shown at size lg only. */
+  readonly showValue: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Accessible name; defaults to the locale's "Loading". */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+  }, "label">>;
+  protected readonly determinate: import("@angular/core").Signal<boolean>;
+  protected readonly clamped: import("@angular/core").Signal<number>;
+  protected readonly percent: import("@angular/core").Signal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdProgressRing, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdProgressRing, "vd-progress-ring", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "showValue": {
+      "alias": "showValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { VdProgressRingSize, VdProgressSize, VdProgressVariant };

package/types/vadem-ui-radio.d.ts

@@ -0,0 +1,11 @@
+import { VdFieldControlBase } from "@vadem/ui/field";
+import * as i0 from "@angular/core";
+/**
+ * Styles a native `<input type="radio">`. Grouping (shared `name`), arrow keys and form values
+ * stay native; wrap each in `label[vdChoice]` and the group in `fieldset[vdFieldset]`.
+ * Spec: specs/radio.md
+ */
+export declare class VdRadio extends VdFieldControlBase {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdRadio, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdRadio, "input[type=radio][vdRadio]", never, {}, {}, never, never, true, never>;
+}

package/types/vadem-ui-range-slider.d.ts

@@ -0,0 +1,136 @@
+import * as i0 from "@angular/core";
+import { OnInit, Signal } from "@angular/core";
+import { FormValueControl } from "@angular/forms/signals";
+type VdRangeValue = readonly [number, number];
+interface VdRangeBounds {
+  min: number;
+  max: number;
+  step: number;
+}
+declare function vdRangeBounds(min: number, max: number, step: number): VdRangeBounds;
+declare function vdRangeSnap(value: number, bounds: VdRangeBounds): number;
+declare function vdRangeValue(value: VdRangeValue | null, bounds: VdRangeBounds): VdRangeValue;
+declare function vdRangeMove(value: VdRangeValue, index: 0 | 1, next: number, bounds: VdRangeBounds): VdRangeValue;
+declare function vdRangeKey(key: string, current: number, min: number, max: number, step: number, rtl: boolean): number | null;
+export declare class VdRangeSlider implements FormValueControl<VdRangeValue | null>, OnInit {
+  readonly value: import("@angular/core").ModelSignal<VdRangeValue | null>;
+  readonly minValue: import("@angular/core").InputSignal<number>;
+  readonly maxValue: import("@angular/core").InputSignal<number>;
+  readonly step: import("@angular/core").InputSignal<number>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly lowerLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly upperLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: Signal<Pick<{
+    lowerLabel: string;
+    upperLabel: string;
+  }, "lowerLabel" | "upperLabel">>;
+  readonly valueText: import("@angular/core").InputSignal<(value: number) => string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  readonly controlId: string;
+  protected readonly labelId: string;
+  protected readonly indices: readonly [0, 1];
+  protected readonly bounds: Signal<VdRangeBounds>;
+  protected readonly selected: Signal<VdRangeValue>;
+  protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
+  protected readonly field: import("@vadem/ui/field").VdFieldContext | null;
+  private readonly host;
+  private readonly rail;
+  private drag;
+  private readonly injector;
+  private readonly destroyRef;
+  private readonly formBound;
+  private readonly ngSource;
+  private readonly ngState;
+  protected readonly isDisabled: Signal<boolean>;
+  protected readonly locked: Signal<boolean>;
+  protected readonly isRequired: Signal<boolean>;
+  protected readonly showInvalid: Signal<boolean>;
+  constructor();
+  ngOnInit(): void;
+  protected percent(index: 0 | 1): number;
+  private choose;
+  protected onKeydown(event: KeyboardEvent, index: 0 | 1): void;
+  private pointerValue;
+  protected onPointerDown(event: PointerEvent): void;
+  protected onPointerMove(event: PointerEvent): void;
+  protected endDrag(event: PointerEvent): void;
+  protected onFocusOut(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdRangeSlider, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdRangeSlider, "vd-range-slider", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "minValue": {
+      "alias": "minValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxValue": {
+      "alias": "maxValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "step": {
+      "alias": "step";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "lowerLabel": {
+      "alias": "lowerLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "upperLabel": {
+      "alias": "upperLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueText": {
+      "alias": "valueText";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+export type { VdRangeValue };