@vadem/ui 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,145 @@
+import * as i0 from "@angular/core";
+import { OnInit } from "@angular/core";
+/** Searchable actions; modal ownership and shortcut bindings stay with consumers. */
+export declare class VdCommand {
+  readonly query: import("@angular/core").ModelSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
+  readonly emptyText: import("@angular/core").InputSignal<string | undefined>;
+  readonly loadingText: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    placeholder: string;
+    emptyText: string;
+    loadingText: string;
+  }, "label" | "placeholder" | "emptyText" | "loadingText">>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly autofocus: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly selected: import("@angular/core").OutputEmitterRef<string>;
+  readonly dismissed: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly expanded: import("@angular/core").WritableSignal<boolean>;
+  protected readonly focused: import("@angular/core").WritableSignal<boolean>;
+  protected readonly listId: string;
+  private readonly items;
+  private readonly initialized;
+  private readonly activeId;
+  private readonly search;
+  private readonly list;
+  private readonly records;
+  protected readonly visibleItems: import("@angular/core").Signal<{
+    id: string;
+    label: string;
+    keywords: readonly string[];
+    disabled: boolean;
+    item: VdCommandItem;
+  }[]>;
+  readonly activeItem: import("@angular/core").Signal<VdCommandItem | null>;
+  constructor();
+  focus(): void;
+  /** Only inspect required inputs after item initialization; queries preserve DOM order. */
+  register(item: VdCommandItem): () => void;
+  isVisible(item: VdCommandItem): boolean;
+  choose(item: VdCommandItem): void;
+  hover(item: VdCommandItem, event: PointerEvent): void;
+  protected onFocus(): void;
+  protected onInput(event: Event): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdCommand, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdCommand, "vd-command", never, {
+    "query": {
+      "alias": "query";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingText": {
+      "alias": "loadingText";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "autofocus": {
+      "alias": "autofocus";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "query": "queryChange";
+    "selected": "selected";
+    "dismissed": "dismissed";
+  }, ["items"], ["*"], true, never>;
+}
+export declare class VdCommandDescription {
+  readonly id: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdCommandDescription, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdCommandDescription, "[vdCommandDescription]", never, {}, {}, never, never, true, never>;
+}
+/** Display hint only; the consumer owns the shortcut binding. */
+export declare class VdCommandShortcut {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdCommandShortcut, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdCommandShortcut, "[vdCommandShortcut]", never, {}, {}, never, never, true, never>;
+}
+export declare class VdCommandItem implements OnInit {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly keywords: import("@angular/core").InputSignal<readonly string[]>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly selected: import("@angular/core").OutputEmitterRef<void>;
+  readonly id: string;
+  readonly el: HTMLElement;
+  protected readonly command: VdCommand;
+  protected readonly description: import("@angular/core").Signal<VdCommandDescription | undefined>;
+  private readonly destroyRef;
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdCommandItem, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdCommandItem, "vd-command-item", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "keywords": {
+      "alias": "keywords";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selected": "selected";
+  }, ["description"], ["[slot=start]", "[vdCommandDescription]", "[vdCommandShortcut]"], true, never>;
+}
+export declare const VD_COMMAND: readonly [typeof VdCommand, typeof VdCommandItem, typeof VdCommandDescription, typeof VdCommandShortcut];

package/types/vadem-ui-copy-button.d.ts

@@ -0,0 +1,90 @@
+import { VdButtonSize, VdButtonVariant } from "@vadem/ui/button";
+import * as i0 from "@angular/core";
+export declare class VdCopyButton {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly variant: import("@angular/core").InputSignal<VdButtonVariant>;
+  readonly size: import("@angular/core").InputSignal<VdButtonSize>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly iconOnly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly copyingLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly copiedLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly errorLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly errorMessage: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    copyingLabel: string;
+    copiedLabel: string;
+    errorLabel: string;
+    errorMessage: string;
+  }, "label" | "copyingLabel" | "copiedLabel" | "errorLabel" | "errorMessage">>;
+  readonly copied: import("@angular/core").OutputEmitterRef<void>;
+  readonly copyFailed: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly state: import("@angular/core").WritableSignal<"idle" | "copying" | "copied" | "error">;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly announcement: import("@angular/core").Signal<string>;
+  protected readonly accessibleLabel: import("@angular/core").Signal<string>;
+  protected readonly title: import("@angular/core").Signal<string>;
+  private readonly document;
+  private readonly destroyRef;
+  private revision;
+  constructor();
+  protected copy(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdCopyButton, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdCopyButton, "vd-copy-button", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconOnly": {
+      "alias": "iconOnly";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "copyingLabel": {
+      "alias": "copyingLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "copiedLabel": {
+      "alias": "copiedLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorLabel": {
+      "alias": "errorLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "copied": "copied";
+    "copyFailed": "copyFailed";
+  }, never, never, true, never>;
+}

package/types/vadem-ui-date-range-picker.d.ts

@@ -0,0 +1,216 @@
+import * as i0 from "@angular/core";
+import { OnInit, Signal } from "@angular/core";
+import { FormValueControl } from "@angular/forms/signals";
+import { VdIsoDate } from "@vadem/ui/calendar";
+interface VdDateRange {
+  readonly start: VdIsoDate;
+  readonly end: VdIsoDate;
+}
+declare function vdValidRange(value: unknown): VdDateRange | null;
+declare function vdRangeAllowed(range: VdDateRange, min: string | null, max: string | null): boolean;
+declare function vdRangeBetween(a: VdIsoDate, b: VdIsoDate): VdDateRange;
+/** Normalize Arabic decimal digits before the shared locale date parser. */
+declare function vdParseRangeDate(text: string, locale: string): VdIsoDate | null;
+type VdDateRangePickerSize = 'sm' | 'md' | 'lg';
+export declare class VdDateRangePicker implements FormValueControl<VdDateRange | null>, OnInit {
+  readonly value: import("@angular/core").ModelSignal<VdDateRange | null>;
+  readonly minDate: import("@angular/core").InputSignal<string | null>;
+  readonly maxDate: import("@angular/core").InputSignal<string | null>;
+  readonly locale: import("@angular/core").InputSignal<string>;
+  readonly firstDayOfWeek: import("@angular/core").InputSignal<number | undefined>;
+  readonly size: import("@angular/core").InputSignal<VdDateRangePickerSize>;
+  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 groupLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly startLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly endLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly openLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly pickerLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly previousLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly nextLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly startInstruction: import("@angular/core").InputSignal<string | undefined>;
+  readonly endInstruction: import("@angular/core").InputSignal<string | undefined>;
+  readonly errorLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Text inputs resolved against the active VD_LOCALE. */
+  protected readonly t: Signal<Pick<{
+    groupLabel: string;
+    startLabel: string;
+    endLabel: string;
+    openLabel: string;
+    pickerLabel: string;
+    previousLabel: string;
+    nextLabel: string;
+    startInstruction: string;
+    endInstruction: string;
+    errorLabel: string;
+  }, "groupLabel" | "startLabel" | "endLabel" | "openLabel" | "pickerLabel" | "previousLabel" | "nextLabel" | "startInstruction" | "endInstruction" | "errorLabel">>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  readonly controlId: string;
+  protected readonly endId: string;
+  protected readonly errorId: string;
+  protected readonly safeMin: Signal<string | null>;
+  protected readonly safeMax: Signal<string | null>;
+  private readonly range;
+  private readonly raw;
+  protected readonly startText: Signal<string>;
+  protected readonly endText: Signal<string>;
+  protected readonly placeholder: Signal<string>;
+  private readonly feedback;
+  protected readonly parseError: Signal<boolean>;
+  protected readonly draftStart: import("@angular/core").WritableSignal<string | null>;
+  protected readonly draftEnd: import("@angular/core").WritableSignal<string | null>;
+  protected readonly selectingEnd: import("@angular/core").WritableSignal<boolean>;
+  protected readonly open: import("@angular/core").WritableSignal<boolean>;
+  protected readonly field: import("@vadem/ui/field").VdFieldContext | null;
+  private readonly host;
+  private readonly popup;
+  private readonly trigger;
+  private readonly startInput;
+  focus(options?: FocusOptions): void;
+  private readonly calendar;
+  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>;
+  private readonly boundsError;
+  protected readonly showInvalid: Signal<boolean>;
+  protected readonly describedBy: Signal<string | null>;
+  protected readonly unavailable: () => boolean;
+  private wasOpen;
+  private lastValue;
+  private lastMin;
+  private lastMax;
+  private editedValue;
+  constructor();
+  ngOnInit(): void;
+  protected format(date: string | null): string;
+  protected edit(event: Event, part: 'start' | 'end'): void;
+  protected commitText(incomplete?: boolean): void;
+  private setRange;
+  protected inputKey(event: KeyboardEvent): void;
+  protected rememberState(): void;
+  protected toggle(): void;
+  protected onToggle(event: Event): void;
+  protected pick(date: string): void;
+  protected leavePopup(event: FocusEvent): void;
+  protected leaveControl(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDateRangePicker, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdDateRangePicker, "vd-date-range-picker", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "minDate": {
+      "alias": "minDate";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxDate": {
+      "alias": "maxDate";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "firstDayOfWeek": {
+      "alias": "firstDayOfWeek";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "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;
+    };
+    "groupLabel": {
+      "alias": "groupLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "startLabel": {
+      "alias": "startLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "endLabel": {
+      "alias": "endLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "openLabel": {
+      "alias": "openLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "pickerLabel": {
+      "alias": "pickerLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "previousLabel": {
+      "alias": "previousLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nextLabel": {
+      "alias": "nextLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "startInstruction": {
+      "alias": "startInstruction";
+      "required": false;
+      "isSignal": true;
+    };
+    "endInstruction": {
+      "alias": "endInstruction";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorLabel": {
+      "alias": "errorLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+export type { VdDateRange, VdDateRangePickerSize };

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

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+type VdDescriptionListLayout = 'horizontal' | 'vertical';
+/** Native term/value groups; consumers own content, actions and missing-value copy. */
+export declare class VdDescriptionList {
+  readonly layout: import("@angular/core").InputSignal<VdDescriptionListLayout>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDescriptionList, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDescriptionList, "dl[vdDescriptionList]", never, {
+    "layout": {
+      "alias": "layout";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { VdDescriptionListLayout };

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

@@ -0,0 +1,174 @@
+import * as i0 from "@angular/core";
+type VdDialogSize = 'sm' | 'md' | 'lg';
+/** `center`: modal dialog. `start` / `end`: drawer attached to that inline edge. */
+type VdDialogPlacement = 'center' | 'start' | 'end';
+/**
+ * Modal dialog on the native `<dialog>` element (top layer, focus trap, inert page and focus
+ * restore come from the platform). Spec: specs/dialog.md
+ */
+export declare class VdDialog {
+  /** Two-way open state. Also controllable with `show()` / `close()`. */
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  readonly size: import("@angular/core").InputSignal<VdDialogSize>;
+  /** Drawers slide in from an inline edge; below the sheet breakpoint every dialog is a sheet. */
+  readonly placement: import("@angular/core").InputSignal<VdDialogPlacement>;
+  /** Escape and backdrop click close the dialog. Turn off for flows that need an explicit choice. */
+  readonly dismissible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emits the dialog's `returnValue` ('' when dismissed) after it closes. */
+  readonly closed: import("@angular/core").OutputEmitterRef<string>;
+  readonly titleId: import("@angular/core").WritableSignal<string | null>;
+  readonly descriptionId: import("@angular/core").WritableSignal<string | null>;
+  private readonly el;
+  private controller?;
+  private sheetDrag?;
+  constructor();
+  show(): void;
+  close(returnValue?: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialog, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialog, "dialog[vdDialog]", ["vdDialog"], {
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+    "dismissible": {
+      "alias": "dismissible";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "openChange";
+    "closed": "closed";
+  }, never, never, true, never>;
+}
+export declare class VdDialogHeader {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogHeader, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialogHeader, "[vdDialogHeader]", never, {}, {}, never, never, true, never>;
+}
+/** Dialog heading; becomes the dialog's accessible name. */
+export declare class VdDialogTitle {
+  readonly id: string;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogTitle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialogTitle, "[vdDialogTitle]", never, {}, {}, never, never, true, never>;
+}
+/** Short description; becomes the dialog's accessible description. */
+export declare class VdDialogDescription {
+  readonly id: string;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogDescription, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialogDescription, "[vdDialogDescription]", never, {}, {}, never, never, true, never>;
+}
+export declare class VdDialogBody {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogBody, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialogBody, "[vdDialogBody]", never, {}, {}, never, never, true, never>;
+}
+export declare class VdDialogFooter {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogFooter, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialogFooter, "[vdDialogFooter]", never, {}, {}, never, never, true, never>;
+}
+/** Closes the surrounding dialog with an optional return value. */
+export declare class VdDialogClose {
+  readonly vdDialogClose: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly dialog: VdDialog;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDialogClose, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDialogClose, "button[vdDialogClose]", never, {
+    "vdDialogClose": {
+      "alias": "vdDialogClose";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const VD_DIALOG: readonly [typeof VdDialog, typeof VdDialogHeader, typeof VdDialogTitle, typeof VdDialogDescription, typeof VdDialogBody, typeof VdDialogFooter, typeof VdDialogClose];
+/**
+ * Framework-agnostic controller for a native modal `<dialog>`: opening/closing, Escape and
+ * light-dismiss policy, and close notification. The platform handles focus trapping, inert
+ * background, top layer and focus restoration.
+ */
+interface VdDialogControllerOptions {
+  /** Called after the dialog closed (any reason) with its `returnValue`. */
+  onClose(returnValue: string): void;
+  /** Whether Escape and backdrop clicks may close the dialog. Read on every attempt. */
+  dismissible(): boolean;
+}
+/** True when the point lies outside the rectangle (i.e. on the ::backdrop). */
+export declare function vdIsOutside(rect: DOMRectReadOnly, x: number, y: number): boolean;
+/**
+ * Width of the root scrollbar gutter on each physical side. Fixed boxes (and top-layer
+ * dialogs) stop at the gutter that `scrollbar-gutter: stable` keeps reserved; which side it is
+ * on depends on the engine and direction, so it is measured with a fixed probe.
+ */
+export declare function vdViewportGutters(doc: Document): {
+  left: number;
+  right: number;
+};
+export declare class VdDialogController {
+  private readonly dialog;
+  private readonly options;
+  private pressStartedOnBackdrop;
+  constructor(dialog: HTMLDialogElement, options: VdDialogControllerOptions);
+  get isOpen(): boolean;
+  open(): void;
+  close(returnValue?: string): void;
+  destroy(): void;
+  private readonly onClose;
+  /** Escape. Prevented for non-dismissible dialogs. */
+  private readonly onCancel;
+  private readonly onPointerDown;
+  private readonly onClick;
+  private isBackdropEvent;
+}
+/**
+ * Framework-agnostic swipe-to-dismiss for a dialog laid out as a bottom sheet.
+ * The element follows the pointer through two custom properties that CSS consumes:
+ *   --vd-sheet-offset   (px, translate down)
+ *   --vd-sheet-progress (0..1, for fading the backdrop)
+ * and gets `data-dragging` while a drag is active (CSS disables transitions then).
+ */
+interface VdSheetDragOptions {
+  /** True while the element is currently laid out as a sheet (read on every gesture). */
+  isSheet(): boolean;
+  dismissible(): boolean;
+  /** Element(s) a drag may start from, e.g. the header that carries the handle. */
+  handleSelector: string;
+  onDismiss(): void;
+}
+/** Pointer travel before a press becomes a drag, so taps and clicks still work. */
+export declare const VD_SHEET_DRAG_THRESHOLD = 6;
+/** Fraction of the sheet height that dismisses on release. */
+export declare const VD_SHEET_DISMISS_DISTANCE = 0.25;
+/** Downward flick speed (px/ms) that dismisses regardless of distance. */
+export declare const VD_SHEET_DISMISS_VELOCITY = 0.5;
+/** Decides what a release does. Pure: exported for tests and other adapters. */
+export declare function vdSheetShouldDismiss(offset: number, height: number, velocity: number): boolean;
+export declare class VdSheetDrag {
+  private readonly el;
+  private readonly options;
+  private pointerId;
+  private start;
+  private samples;
+  private dragging;
+  private offset;
+  private height;
+  constructor(el: HTMLElement, options: VdSheetDragOptions);
+  destroy(): void;
+  private readonly onDown;
+  private readonly onMove;
+  private readonly onUp;
+  private readonly onCancel;
+  /** Downward speed over the most recent samples, px/ms. */
+  private velocity;
+  private reset;
+}
+export type { VdDialogControllerOptions, VdDialogPlacement, VdDialogSize, VdSheetDragOptions };