@vadem/ui 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,303 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, ModelSignal, OnInit, Signal } from "@angular/core";
+import { ControlValueAccessor } from "@angular/forms";
+/** One option of select, combobox, or multi-select. Specs: select.md, multi-select.md. */
+export declare class VdOption implements OnInit {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Text for the trigger, typeahead and filtering. Defaults to the option's text content. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly host: VdListboxHost;
+  readonly el: HTMLElement;
+  readonly id: string;
+  private readonly destroyRef;
+  protected readonly selected: import("@angular/core").Signal<boolean>;
+  protected readonly active: import("@angular/core").Signal<boolean>;
+  protected readonly visible: import("@angular/core").Signal<boolean>;
+  textLabel(): string;
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdOption, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdOption, "vd-option", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** What an option needs from the select, combobox, or multi-select that owns it. */
+interface VdListboxHost {
+  isSelected(option: VdOption): boolean;
+  isActive(option: VdOption): boolean;
+  isVisible(option: VdOption): boolean;
+  choose(option: VdOption): void;
+  hover(option: VdOption): void;
+  register(option: VdOption): () => void;
+}
+declare const VD_LISTBOX: InjectionToken<VdListboxHost>;
+type VdSelectSize = 'sm' | 'md' | 'lg';
+/**
+ * Shared behavior of select, combobox, and multi-select: option registry, active option
+ * (aria-activedescendant - focus stays on the combobox element), popover listbox anchored to
+ * the field, value + ControlValueAccessor, and `vd-field` wiring.
+ */
+declare abstract class VdListboxBase<T = string | null> implements VdListboxHost, ControlValueAccessor, OnInit {
+  /** Concrete controls define a single-value or array-valued selection model. */
+  abstract readonly value: ModelSignal<T>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly size: import("@angular/core").InputSignal<VdSelectSize>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Invalid state (e.g. server error); form validity is detected after touch. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Gate for `invalid`; Signal Forms binds it (FormUiControl contract). */
+  readonly touched: import("@angular/core").InputSignal<boolean | undefined>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Shown when no option is visible (e.g. nothing matches the filter). */
+  readonly emptyText: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: Signal<Pick<{
+    emptyText: string;
+  }, "emptyText">>;
+  /** Accessible name when there's no `vd-field` label; applied to the inner combobox element. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
+  readonly listboxId: string;
+  readonly controlId: string;
+  protected readonly field: import("@vadem/ui/field").VdFieldContext | null;
+  protected readonly hostEl: HTMLElement;
+  private readonly injector;
+  private readonly destroyRef;
+  private readonly options;
+  protected readonly open: import("@angular/core").WritableSignal<boolean>;
+  protected readonly activeId: import("@angular/core").WritableSignal<string | null>;
+  private readonly formDisabled;
+  private readonly ngSource;
+  private readonly typeahead;
+  /** The popover listbox element. */
+  protected abstract listEl(): HTMLElement | undefined;
+  /** What the listbox is anchored to (the visible field). */
+  protected abstract anchorEl(): HTMLElement | undefined;
+  protected readonly ordered: Signal<VdOption[]>;
+  protected readonly visibleOptions: Signal<VdOption[]>;
+  protected readonly selectedOption: Signal<VdOption | undefined>;
+  protected readonly selectedLabel: Signal<string>;
+  protected readonly isDisabled: Signal<boolean>;
+  private readonly ngState;
+  protected readonly showInvalid: Signal<boolean>;
+  protected readonly isRequired: Signal<boolean>;
+  protected readonly describedBy: Signal<string | null>;
+  private onChange;
+  private onTouched;
+  constructor();
+  ngOnInit(): void;
+  abstract isSelected(option: VdOption): boolean;
+  isActive(option: VdOption): boolean;
+  isVisible(_option: VdOption): boolean;
+  abstract choose(option: VdOption): void;
+  hover(option: VdOption): void;
+  register(option: VdOption): () => void;
+  abstract writeValue(value: T | null): void;
+  registerOnChange(fn: (value: T) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(disabled: boolean): void;
+  /** Hook for subclasses after an option was chosen. */
+  protected onChosen(_option: VdOption): void;
+  /** Hook for subclasses after the list closed (any reason). */
+  protected onClosed(): void;
+  protected setValue(value: T): void;
+  protected markTouched(): void;
+  protected openList(start?: 'selected' | 'first' | 'last'): void;
+  protected closeList(): void;
+  protected activate(start: 'selected' | 'first' | 'last'): void;
+  /** Handles list navigation keys. Returns true when the key was used. */
+  protected navigate(event: KeyboardEvent): boolean;
+  /** Feeds a printable key to typeahead. Returns the matched option, if any. */
+  protected typeaheadMatch(event: KeyboardEvent): VdOption | undefined;
+  protected activeOption(): VdOption | undefined;
+  private afterClose;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdListboxBase<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdListboxBase<any>, never, never, {
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "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;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledby": {
+      "alias": "aria-labelledby";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Editable combobox with list autocomplete (APG): type to filter, pick with arrows + Enter or
+ * click. The value is always one of the options; free text reverts on blur. Spec: specs/select.md
+ */
+export declare class VdCombobox extends VdListboxBase {
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  isSelected(option: VdOption): boolean;
+  writeValue(value: string | null): void;
+  choose(option: VdOption): void;
+  private readonly fieldRef;
+  private readonly inputRef;
+  private readonly list;
+  /** Text being typed; `null` when not filtering (the input shows the selected label). */
+  private readonly query;
+  protected readonly inputText: import("@angular/core").Signal<string>;
+  protected listEl(): HTMLElement | undefined;
+  protected anchorEl(): HTMLElement | undefined;
+  focus(): void;
+  isVisible(option: VdOption): boolean;
+  protected onChosen(): void;
+  protected onClosed(): void;
+  /** Whether the list was open when the press started (light dismiss may close it first). */
+  private wasOpen;
+  protected onFieldPointerDown(event: PointerEvent): void;
+  protected onFieldClick(event: MouseEvent): void;
+  protected onInput(event: Event): void;
+  protected onBlur(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdCombobox, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdCombobox, "vd-combobox", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+/** Searchable multiple selection. Spec: specs/multi-select.md. */
+export declare class VdMultiSelect extends VdListboxBase<string[]> {
+  readonly value: import("@angular/core").ModelSignal<string[]>;
+  readonly removeLabel: import("@angular/core").InputSignal<((label: string) => string) | undefined>;
+  readonly selectionLabel: import("@angular/core").InputSignal<((count: number) => string) | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly multiTexts: import("@angular/core").Signal<Pick<{
+    removeLabel: (label: string) => string;
+    selectionLabel: (count: number) => string;
+  }, "removeLabel" | "selectionLabel">>;
+  private readonly fieldRef;
+  private readonly inputRef;
+  private readonly list;
+  protected readonly query: import("@angular/core").WritableSignal<string>;
+  protected readonly summaryId: string;
+  protected readonly descriptionIds: import("@angular/core").Signal<string>;
+  protected readonly selectedItems: import("@angular/core").Signal<{
+    value: string;
+    label: string;
+    disabled: boolean;
+  }[]>;
+  constructor();
+  protected listEl(): HTMLElement | undefined;
+  protected anchorEl(): HTMLElement | undefined;
+  focus(): void;
+  isSelected(option: VdOption): boolean;
+  isVisible(option: VdOption): boolean;
+  choose(option: VdOption): void;
+  writeValue(value: string[] | null): void;
+  protected remove(value: string): void;
+  protected onInput(event: Event): void;
+  protected onFocusOut(event: FocusEvent): void;
+  protected onFieldPointerDown(event: PointerEvent): void;
+  protected onClosed(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdMultiSelect, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdMultiSelect, "vd-multi-select", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLabel": {
+      "alias": "removeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionLabel": {
+      "alias": "selectionLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Select-only combobox (APG): a button that opens a listbox; focus stays on the button and the
+ * active option is exposed with aria-activedescendant. Spec: specs/select.md
+ */
+export declare class VdSelect extends VdListboxBase {
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  isSelected(option: VdOption): boolean;
+  writeValue(value: string | null): void;
+  choose(option: VdOption): void;
+  private readonly trigger;
+  private readonly list;
+  /** Light dismiss closes the list on pointerdown; the following click must not reopen it. */
+  protected wasOpen: boolean;
+  protected listEl(): HTMLElement | undefined;
+  protected anchorEl(): HTMLElement | undefined;
+  focus(): void;
+  protected onClick(): void;
+  protected onBlur(): void;
+  protected onClosed(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSelect, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdSelect, "vd-select", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+export type { VdSelectSize };

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

@@ -0,0 +1,70 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+type VdSidebarMode = 'docked' | 'drawer';
+/** Sidebar content, authored once and rendered either docked or inside the drawer. */
+export declare class VdSidebar {
+  readonly template: TemplateRef<any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSidebar, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSidebar, "ng-template[vdSidebar]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * App shell: docked sidebar (collapsible to an icon rail) on wide viewports, start-edge
+ * Dialog drawer on narrow ones. The breakpoint lives in CSS. Spec: specs/sidebar.md
+ */
+export declare class VdSidebarLayout {
+  /** Drawer dialog title. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Accessible name of the drawer close button. */
+  readonly closeLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    closeLabel: string;
+  }, "label" | "closeLabel">>;
+  /** Docked rail state. */
+  readonly collapsed: import("@angular/core").ModelSignal<boolean>;
+  readonly sidebarId: string;
+  readonly mode: import("@angular/core").WritableSignal<VdSidebarMode>;
+  readonly drawerOpen: import("@angular/core").WritableSignal<boolean>;
+  /** Collapsed rail is only visible while docked; the drawer always shows full content. */
+  readonly rail: import("@angular/core").Signal<boolean>;
+  protected readonly content: import("@angular/core").Signal<VdSidebar | undefined>;
+  private readonly docked;
+  private readonly drawer;
+  private readonly drawerBody;
+  private readonly el;
+  constructor();
+  /** Collapses/expands the rail when docked, opens the drawer otherwise. */
+  toggle(): void;
+  /** Following a link closes the drawer; modified clicks open elsewhere and keep it open. */
+  private closeOnNavigate;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSidebarLayout, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdSidebarLayout, "vd-sidebar-layout", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapsed": {
+      "alias": "collapsed";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "collapsed": "collapsedChange";
+  }, ["content"], ["*"], true, never>;
+}
+/** Toggles the rail (docked) or opens the drawer (narrow viewports). */
+export declare class VdSidebarToggle {
+  protected readonly layout: VdSidebarLayout;
+  protected readonly expanded: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSidebarToggle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSidebarToggle, "button[vdSidebarToggle]", never, {}, {}, never, never, true, never>;
+}
+export declare const VD_SIDEBAR: readonly [typeof VdSidebarLayout, typeof VdSidebar, typeof VdSidebarToggle];
+export type { VdSidebarMode };

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

@@ -0,0 +1,28 @@
+import * as i0 from "@angular/core";
+type VdSkeletonShape = 'text' | 'circle' | 'rectangle';
+type VdSkeletonSize = 'sm' | 'md' | 'lg';
+/** Decorative placeholder. Loading status and lifecycle belong to its consumer. */
+export declare class VdSkeleton {
+  readonly shape: import("@angular/core").InputSignal<VdSkeletonShape | null>;
+  readonly size: import("@angular/core").InputSignal<VdSkeletonSize>;
+  readonly animated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSkeleton, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSkeleton, "[vdSkeleton]", never, {
+    "shape": {
+      "alias": "shape";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "animated": {
+      "alias": "animated";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { VdSkeletonShape, VdSkeletonSize };

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

@@ -0,0 +1,17 @@
+import { VdFieldControlBase } from "@vadem/ui/field";
+import * as i0 from "@angular/core";
+/** Filled share of a range input in percent (0-100), from its min/max/value. */
+export declare function vdSliderFill(value: number, min: number, max: number): number;
+/**
+ * Styles a native `<input type="range">`. Value, keyboard (arrows, PageUp/Down, Home/End),
+ * forms and labelling stay native; the directive only keeps the filled part of the track in
+ * sync (`--vd-slider-fill`) for engines without a native progress pseudo-element.
+ * Spec: specs/slider.md
+ */
+export declare class VdSlider extends VdFieldControlBase {
+  private readonly el;
+  constructor();
+  protected sync(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSlider, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSlider, "input[type=range][vdSlider]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,99 @@
+import { VdOrientation } from "@vadem/ui/keyboard";
+import * as i0 from "@angular/core";
+interface VdSplitterBounds {
+  min: number;
+  max: number;
+}
+/** Nonzero panes keep their scrollable content reachable; invalid/reversed bounds become fixed. */
+declare function vdSplitterBounds(min: number, max: number): VdSplitterBounds;
+declare function vdSplitterValue(value: number, bounds: VdSplitterBounds): number;
+declare function vdSplitterKey(key: string, value: number, bounds: VdSplitterBounds, orientation: 'horizontal' | 'vertical', dir: 'ltr' | 'rtl', step: number): number | null;
+declare function vdSplitterDrag(value: number, delta: number, span: number, bounds: VdSplitterBounds, reverse: boolean): number;
+export declare class VdSplitter {
+  readonly value: import("@angular/core").ModelSignal<number>;
+  readonly min: import("@angular/core").InputSignal<number>;
+  readonly max: import("@angular/core").InputSignal<number>;
+  readonly step: import("@angular/core").InputSignal<number>;
+  /** Layout axis: horizontal means side by side, vertical means stacked panes. */
+  readonly orientation: import("@angular/core").InputSignal<VdOrientation>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dragging: import("@angular/core").WritableSignal<boolean>;
+  readonly bounds: import("@angular/core").Signal<VdSplitterBounds>;
+  readonly position: import("@angular/core").Signal<number>;
+  private readonly descendants;
+  readonly panes: import("@angular/core").Signal<VdSplitterPane[]>;
+  readonly locked: import("@angular/core").Signal<boolean>;
+  readonly element: HTMLElement;
+  resize(value: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSplitter, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSplitter, "[vdSplitter]", ["vdSplitter"], {
+    "value": {
+      "alias": "value";
+      "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;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, ["descendants"], never, true, never>;
+}
+export declare class VdSplitterPane {
+  readonly splitter: VdSplitter;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly element: HTMLElement;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSplitterPane, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSplitterPane, "[vdSplitterPane]", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class VdSplitterHandle {
+  /** Match the primary pane's name; consumers can provide aria-labelledby for its heading. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly splitter: VdSplitter;
+  private readonly element;
+  private drag;
+  constructor();
+  private direction;
+  protected onKeydown(event: KeyboardEvent): void;
+  protected onPointerDown(event: PointerEvent): void;
+  protected onPointerMove(event: PointerEvent): void;
+  protected onPointerEnd(event: PointerEvent): void;
+  private finish;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSplitterHandle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdSplitterHandle, "[vdSplitterHandle]", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const VD_SPLITTER: readonly [typeof VdSplitter, typeof VdSplitterPane, typeof VdSplitterHandle];

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

@@ -0,0 +1,101 @@
+import { VdBadgeVariant } from "@vadem/ui/badge";
+import * as i0 from "@angular/core";
+type VdStatTrend = 'up' | 'down' | 'flat';
+/** Whether the change is good news; defaults from the trend (up = positive). */
+type VdStatSentiment = 'positive' | 'negative' | 'neutral';
+type VdStatSize = 'sm' | 'md';
+/**
+ * A key figure: label, value, optional change and caption. Values arrive formatted by the
+ * application (Intl). Spec: specs/stat.md
+ */
+export declare class VdStat {
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Formatted value, e.g. "₴ 48 920". */
+  readonly value: import("@angular/core").InputSignal<string>;
+  /** Formatted change, e.g. "+12,4%". */
+  readonly delta: import("@angular/core").InputSignal<string | undefined>;
+  readonly trend: import("@angular/core").InputSignal<VdStatTrend>;
+  readonly sentiment: import("@angular/core").InputSignal<VdStatSentiment | undefined>;
+  readonly caption: import("@angular/core").InputSignal<string | undefined>;
+  readonly size: import("@angular/core").InputSignal<VdStatSize>;
+  /** Placeholders while the figure loads; the label stays visible. */
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly increaseLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly decreaseLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly unchangedLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    increaseLabel: string;
+    decreaseLabel: string;
+    unchangedLabel: string;
+  }, "increaseLabel" | "decreaseLabel" | "unchangedLabel">>;
+  protected readonly resolvedSentiment: import("@angular/core").Signal<VdStatSentiment>;
+  /** The change uses the library's Badge, coloured by sentiment. */
+  protected readonly badgeVariant: import("@angular/core").Signal<VdBadgeVariant>;
+  /**
+   * Numbers and currency signs have no strong direction, so an isolated value would inherit the
+   * page's RTL and reverse "₴ 48 920". Values with RTL letters ("48 ر.س") stay RTL.
+   */
+  protected directionOf(text: string): 'ltr' | 'rtl';
+  /** Direction in words: color and arrow are only extra cues. */
+  protected readonly trendName: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdStat, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdStat, "vd-stat", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "delta": {
+      "alias": "delta";
+      "required": false;
+      "isSignal": true;
+    };
+    "trend": {
+      "alias": "trend";
+      "required": false;
+      "isSignal": true;
+    };
+    "sentiment": {
+      "alias": "sentiment";
+      "required": false;
+      "isSignal": true;
+    };
+    "caption": {
+      "alias": "caption";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "increaseLabel": {
+      "alias": "increaseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "decreaseLabel": {
+      "alias": "decreaseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "unchangedLabel": {
+      "alias": "unchangedLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export type { VdStatSentiment, VdStatSize, VdStatTrend };