@vadem/ui 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,73 @@
+import * as i0 from "@angular/core";
+/**
+ * Whether a file matches an `accept` attribute value, the way the file picker filters:
+ * extensions (".pdf"), exact MIME types ("image/png") and wildcards ("image/*"), comma-separated.
+ * An empty `accept` accepts everything. Dropped files bypass the picker, so they are checked here.
+ */
+export declare function vdAcceptsFile(file: {
+  name: string;
+  type: string;
+}, accept: string): boolean;
+interface VdFileCheck {
+  accept?: string;
+  /** Bytes. */
+  maxSize?: number;
+  /** Keep at most this many accepted files (e.g. 1 when `multiple` is off). */
+  maxFiles?: number;
+}
+type VdFileRejection = 'type' | 'size' | 'count';
+/** Splits files into accepted and rejected (with the reason), in their original order. */
+export declare function vdCheckFiles<T extends {
+  name: string;
+  type: string;
+  size: number;
+}>(files: readonly T[], check: VdFileCheck): {
+  accepted: T[];
+  rejected: {
+    file: T;
+    reason: VdFileRejection;
+  }[];
+};
+interface VdRejectedFile {
+  file: File;
+  reason: VdFileRejection;
+}
+/**
+ * File picker and drop target on a `<label>` that wraps a native `<input type="file">`.
+ * The input stays the control (keyboard, `accept`, `multiple`, form submission); the label is
+ * the click and drop area. Dropped files are checked against `accept` (the picker does that
+ * for chosen files), `maxSize` and `multiple`, and written back to the input.
+ * Spec: specs/dropzone.md
+ */
+export declare class VdDropzone {
+  /** Largest accepted file in bytes. */
+  readonly maxSize: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+  /** Accepted files, after each pick or drop. */
+  readonly filesSelected: import("@angular/core").OutputEmitterRef<File[]>;
+  /** Files that didn't pass `accept`, `maxSize` or the single-file limit. */
+  readonly filesRejected: import("@angular/core").OutputEmitterRef<VdRejectedFile[]>;
+  protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
+  private readonly el;
+  /** dragenter/leave fire for every child; count to know when the pointer really left. */
+  private depth;
+  private get control();
+  protected onDragEnter(event: DragEvent): void;
+  protected onDragOver(event: DragEvent): void;
+  protected onDragLeave(): void;
+  protected onDrop(event: DragEvent): void;
+  protected onChange(event: Event): void;
+  private emit;
+  private acceptsDrag;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdDropzone, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdDropzone, "label[vdDropzone]", never, {
+    "maxSize": {
+      "alias": "maxSize";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "filesSelected": "filesSelected";
+    "filesRejected": "filesRejected";
+  }, never, never, true, never>;
+}
+export type { VdFileCheck, VdFileRejection, VdRejectedFile };

package/types/vadem-ui-editable-text.d.ts

@@ -0,0 +1,141 @@
+import * as i0 from "@angular/core";
+type VdEditableTextSave = (value: string) => void | Promise<void>;
+/** A committed value with a separate draft and explicit application-owned persistence. */
+export declare class VdEditableText {
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly save: import("@angular/core").InputSignal<VdEditableTextSave | undefined>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly maxLength: import("@angular/core").InputSignal<number | null>;
+  readonly hint: import("@angular/core").InputSignal<string | undefined>;
+  readonly emptyText: import("@angular/core").InputSignal<string | undefined>;
+  readonly editLabel: import("@angular/core").InputSignal<((label: string, value: string) => string) | undefined>;
+  readonly saveLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly cancelLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly savingText: import("@angular/core").InputSignal<string | undefined>;
+  readonly savedText: import("@angular/core").InputSignal<string | undefined>;
+  readonly saveErrorText: import("@angular/core").InputSignal<string | undefined>;
+  readonly requiredText: import("@angular/core").InputSignal<string | undefined>;
+  readonly tooLongText: import("@angular/core").InputSignal<((limit: number) => string) | undefined>;
+  readonly saveFailed: import("@angular/core").OutputEmitterRef<unknown>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    emptyText: string;
+    editLabel: (label: string, value: string) => string;
+    saveLabel: string;
+    cancelLabel: string;
+    savingText: string;
+    savedText: string;
+    saveErrorText: string;
+    requiredText: string;
+    tooLongText: (limit: number) => string;
+  }, "emptyText" | "editLabel" | "saveLabel" | "cancelLabel" | "savingText" | "savedText" | "saveErrorText" | "requiredText" | "tooLongText">>;
+  protected readonly editing: import("@angular/core").WritableSignal<boolean>;
+  protected readonly saving: import("@angular/core").WritableSignal<boolean>;
+  protected readonly draft: import("@angular/core").WritableSignal<string>;
+  protected readonly issue: import("@angular/core").WritableSignal<"required" | "tooLong" | "save" | null>;
+  protected readonly limit: import("@angular/core").Signal<number | null>;
+  protected readonly feedback: import("@angular/core").Signal<string>;
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  protected composing: boolean;
+  private readonly host;
+  private readonly editor;
+  private readonly trigger;
+  private readonly injector;
+  private destroyed;
+  constructor();
+  private focusAfterRender;
+  protected begin(): void;
+  protected changeDraft(event: Event): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  protected cancel(): void;
+  protected commit(): Promise<void>;
+  private finish;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdEditableText, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdEditableText, "vd-editable-text", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "save": {
+      "alias": "save";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxLength": {
+      "alias": "maxLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "editLabel": {
+      "alias": "editLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "saveLabel": {
+      "alias": "saveLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelLabel": {
+      "alias": "cancelLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "savingText": {
+      "alias": "savingText";
+      "required": false;
+      "isSignal": true;
+    };
+    "savedText": {
+      "alias": "savedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "saveErrorText": {
+      "alias": "saveErrorText";
+      "required": false;
+      "isSignal": true;
+    };
+    "requiredText": {
+      "alias": "requiredText";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooLongText": {
+      "alias": "tooLongText";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "saveFailed": "saveFailed";
+  }, never, never, true, never>;
+}
+export type { VdEditableTextSave };

package/types/vadem-ui-empty-state.d.ts

@@ -0,0 +1,34 @@
+import * as i0 from "@angular/core";
+type VdEmptyStateSize = 'sm' | 'md';
+/**
+ * What to show when there is nothing yet (first run), nothing matches (filters), or nothing is
+ * left (inbox zero): an icon, a title, one sentence, and the next step. Spec: specs/empty-state.md
+ */
+export declare class VdEmptyState {
+  readonly icon: import("@angular/core").InputSignal<"activity" | "alert-circle" | "alert-triangle" | "arrow-down" | "arrow-left" | "arrow-right" | "arrow-up" | "arrow-up-down" | "bell" | "calendar" | "check" | "check-circle" | "chevron-down" | "chevron-left" | "chevron-right" | "chevron-up" | "copy" | "credit-card" | "download" | "external-link" | "eye" | "eye-off" | "file" | "folder" | "git-branch" | "globe" | "info" | "key" | "layout-dashboard" | "loader" | "lock" | "log-out" | "mail" | "menu" | "minus" | "monitor" | "moon" | "more-horizontal" | "panel-left" | "pencil" | "plus" | "rocket" | "search" | "settings" | "shield" | "star" | "sun" | "trash" | "trending-down" | "trending-up" | "upload" | "user" | "users" | "x" | "x-circle" | null>;
+  /** `sm` fits table cells, cards and menus; `md` fills a page section. */
+  readonly size: import("@angular/core").InputSignal<VdEmptyStateSize>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdEmptyState, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdEmptyState, "[vdEmptyState]", never, {
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*", "[slot=actions]"], true, never>;
+}
+export declare class VdEmptyStateTitle {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdEmptyStateTitle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdEmptyStateTitle, "[vdEmptyStateTitle]", never, {}, {}, never, never, true, never>;
+}
+export declare class VdEmptyStateDescription {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdEmptyStateDescription, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdEmptyStateDescription, "[vdEmptyStateDescription]", never, {}, {}, never, never, true, never>;
+}
+export declare const VD_EMPTY_STATE: readonly [typeof VdEmptyState, typeof VdEmptyStateTitle, typeof VdEmptyStateDescription];
+export type { VdEmptyStateSize };

package/types/vadem-ui-expandable-text.d.ts

@@ -0,0 +1,52 @@
+import * as i0 from "@angular/core";
+/** Length-based plain-text disclosure with exact source preservation. */
+export declare class VdExpandableText {
+  readonly text: import("@angular/core").InputSignal<string>;
+  readonly previewLength: import("@angular/core").InputSignal<number>;
+  readonly expanded: import("@angular/core").ModelSignal<boolean>;
+  readonly expandLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly collapseLabel: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    expandLabel: string;
+    collapseLabel: string;
+  }, "expandLabel" | "collapseLabel">>;
+  protected readonly parts: import("@angular/core").Signal<{
+    preview: string;
+    rest: string;
+  }>;
+  protected readonly hasMore: import("@angular/core").Signal<boolean>;
+  protected readonly restId: string;
+  private readonly host;
+  private recoverFocus;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdExpandableText, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdExpandableText, "vd-expandable-text", never, {
+    "text": {
+      "alias": "text";
+      "required": true;
+      "isSignal": true;
+    };
+    "previewLength": {
+      "alias": "previewLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "expanded": {
+      "alias": "expanded";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandLabel": {
+      "alias": "expandLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapseLabel": {
+      "alias": "collapseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "expanded": "expandedChange";
+  }, never, never, true, never>;
+}

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

@@ -0,0 +1,180 @@
+import * as i0 from "@angular/core";
+import { DestroyRef, InjectionToken, OnInit, Signal } from "@angular/core";
+import { NgControl } from "@angular/forms";
+/**
+ * Label that wraps a checkbox, switch or radio and its text. The whole label is the hit area;
+ * the text is the control's accessible name. Spec: specs/checkbox.md
+ */
+export declare class VdChoice {
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdChoice, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdChoice, "label[vdChoice]", never, {}, {}, never, never, true, never>;
+}
+/** What a form control exposes to its surrounding `vd-field`. */
+interface VdFieldControl {
+  readonly id: Signal<string>;
+  readonly invalid: Signal<boolean>;
+  readonly required: Signal<boolean>;
+  readonly disabled: Signal<boolean>;
+}
+/** What `vd-field` exposes to the control inside it. */
+interface VdFieldContext {
+  /** Space-separated ids for `aria-describedby` (hint or error), or null. */
+  readonly describedBy: Signal<string | null>;
+  register(control: VdFieldControl): void;
+  unregister(control: VdFieldControl): void;
+}
+export declare const VD_FIELD: InjectionToken<VdFieldContext>;
+/** Deterministic per-app id. Same creation order on server and client keeps hydration stable. */
+export declare function vdUniqueId(prefix: string): string;
+/**
+ * Label, hint and error around one form control. Wires `for`, `aria-describedby`,
+ * and the required marker automatically. Spec: specs/field.md
+ */
+export declare class VdField implements VdFieldContext {
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly hint: import("@angular/core").InputSignal<string | undefined>;
+  /** Additional descriptive IDs, e.g. a character counter; retained beside hint/error. */
+  readonly descriptionIds: import("@angular/core").InputSignal<string | undefined>;
+  /** Message shown while the control is invalid. Replaces the hint. */
+  readonly error: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly control: import("@angular/core").WritableSignal<VdFieldControl | null>;
+  protected readonly hintId: string;
+  protected readonly errorId: string;
+  protected readonly showError: import("@angular/core").Signal<boolean>;
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  register(control: VdFieldControl): void;
+  unregister(control: VdFieldControl): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdField, "vd-field", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "descriptionIds": {
+      "alias": "descriptionIds";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+type VdFieldsetOrientation = 'vertical' | 'horizontal';
+/**
+ * Legend, hint and error around a group of choices (radios, checkboxes). The group is named by
+ * the legend; hint and error describe the fieldset itself, so they are announced once when the
+ * group is entered, not on every option. Spec: specs/field.md
+ */
+export declare class VdFieldset implements VdFieldContext {
+  readonly legend: import("@angular/core").InputSignal<string | undefined>;
+  readonly hint: import("@angular/core").InputSignal<string | undefined>;
+  /** Shown while any control in the group is displayed invalid. */
+  readonly error: import("@angular/core").InputSignal<string | undefined>;
+  readonly orientation: import("@angular/core").InputSignal<VdFieldsetOrientation>;
+  protected readonly controls: import("@angular/core").WritableSignal<readonly VdFieldControl[]>;
+  protected readonly hintId: string;
+  protected readonly errorId: string;
+  protected readonly required: import("@angular/core").Signal<boolean>;
+  protected readonly showError: import("@angular/core").Signal<boolean>;
+  protected readonly groupDescribedBy: import("@angular/core").Signal<string | null>;
+  /** Controls aren't described individually: the fieldset carries the description. */
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  register(control: VdFieldControl): void;
+  unregister(control: VdFieldControl): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdFieldset, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdFieldset, "fieldset[vdFieldset]", never, {
+    "legend": {
+      "alias": "legend";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Shared behavior for controls on native form elements (input, checkbox, switch):
+ * displayed validity from Reactive/Template forms or Signal Forms, `vd-field` registration,
+ * and the ARIA/data attributes that go with it. Not part of the styling contract.
+ */
+export declare abstract class VdFieldControlBase implements OnInit {
+  /** Invalid state (e.g. a server error). Reactive/Template form validity is detected on its own. */
+  readonly invalid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Optional gate for `invalid`: when explicitly false the error isn't shown yet. Signal Forms
+   * binds `invalid`, `touched` and `required` here automatically (FormUiControl contract).
+   */
+  readonly touched: import("@angular/core").InputSignal<boolean | undefined>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly id: import("@angular/core").InputSignal<string>;
+  protected readonly field: import("@vadem/ui/field").VdFieldContext | null;
+  private readonly ngControl;
+  private readonly formField;
+  private readonly destroyRef;
+  /** Mirrored Reactive/Template forms state; set once the control is resolved (ngOnInit). */
+  private readonly ngSource;
+  private readonly ngState;
+  /** Invalid as displayed: forced, or form-invalid after the user has touched the control. */
+  readonly showInvalid: Signal<boolean>;
+  private readonly fieldControl;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdFieldControlBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdFieldControlBase, never, never, {
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+interface VdNgControlState {
+  invalid: boolean;
+  touched: boolean;
+  disabled: boolean;
+  required: boolean;
+}
+/**
+ * Mirrors a Reactive/Template forms control into a signal (NgControl isn't signal-based).
+ * Call once the control is resolved (ngOnInit or later). Returns a static empty state when
+ * there's no control or it's a Signal Forms shim without `events`.
+ */
+export declare function vdNgControlState(ngControl: NgControl | null, destroyRef: DestroyRef): Signal<VdNgControlState>;
+export type { VdFieldContext, VdFieldControl, VdFieldsetOrientation, VdNgControlState };

package/types/vadem-ui-file-preview.d.ts

@@ -0,0 +1,108 @@
+import { SafeResourceUrl } from "@angular/platform-browser";
+import * as i0 from "@angular/core";
+type PreviewState = 'empty' | 'preparing' | 'loading' | 'ready' | 'error' | 'unsupported' | 'pdf';
+interface PreviewSource {
+  file: Blob;
+  url: string;
+  pdf: SafeResourceUrl | null;
+}
+/** Local file presentation. The caller owns file acquisition and validation. */
+export declare class VdFilePreview {
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  readonly file: import("@angular/core").InputSignal<Blob | null>;
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  readonly alt: import("@angular/core").InputSignal<string | undefined>;
+  readonly closeLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly downloadLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly loadingText: import("@angular/core").InputSignal<string | undefined>;
+  readonly errorText: import("@angular/core").InputSignal<string | undefined>;
+  readonly emptyText: import("@angular/core").InputSignal<string | undefined>;
+  readonly unsupportedText: import("@angular/core").InputSignal<string | undefined>;
+  readonly pdfText: import("@angular/core").InputSignal<string | undefined>;
+  readonly titleText: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    title: string;
+    closeLabel: string;
+    downloadLabel: string;
+    loadingText: string;
+    errorText: string;
+    emptyText: string;
+    unsupportedText: string;
+    pdfText: string;
+  }, "title" | "closeLabel" | "downloadLabel" | "loadingText" | "errorText" | "emptyText" | "unsupportedText" | "pdfText">>;
+  protected readonly title: import("@angular/core").Signal<string>;
+  protected readonly filename: import("@angular/core").Signal<string>;
+  protected readonly kind: import("@angular/core").Signal<"unsupported" | "pdf" | "image">;
+  private readonly allocated;
+  protected readonly source: import("@angular/core").Signal<PreviewSource | null>;
+  protected readonly sources: import("@angular/core").Signal<PreviewSource[]>;
+  private readonly imageResult;
+  protected readonly state: import("@angular/core").Signal<PreviewState>;
+  constructor();
+  protected imageState(source: PreviewSource, state: 'ready' | 'error'): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdFilePreview, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdFilePreview, "vd-file-preview", never, {
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "file": {
+      "alias": "file";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "alt": {
+      "alias": "alt";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "downloadLabel": {
+      "alias": "downloadLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingText": {
+      "alias": "loadingText";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorText": {
+      "alias": "errorText";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "unsupportedText": {
+      "alias": "unsupportedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "pdfText": {
+      "alias": "pdfText";
+      "required": false;
+      "isSignal": true;
+    };
+    "titleText": {
+      "alias": "titleText";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "openChange";
+  }, never, never, true, never>;
+}

package/types/vadem-ui-file-size.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import { PipeTransform } from "@angular/core";
+type VdFileSizeSystem = 'decimal' | 'binary';
+interface VdFileSizeOptions {
+  readonly locale?: string;
+  readonly system?: VdFileSizeSystem;
+  readonly maximumFractionDigits?: number;
+  readonly unknownText?: string;
+}
+/** Formats byte counts only; display strings are never parsed back into values. */
+export declare function vdFormatFileSize(bytes: number | null | undefined, options?: VdFileSizeOptions): string;
+export declare class VdFileSizePipe implements PipeTransform {
+  private readonly texts;
+  transform(bytes: number | null | undefined, system?: VdFileSizeSystem, maximumFractionDigits?: number, locale?: string, unknownText?: string): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdFileSizePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<VdFileSizePipe, "vdFileSize", true>;
+}
+export type { VdFileSizeOptions, VdFileSizeSystem };

package/types/vadem-ui-form-error-summary.d.ts

@@ -0,0 +1,46 @@
+import * as i0 from "@angular/core";
+interface VdFormError {
+  /** Raw ID of a visible, enabled, focusable control in the same document. */
+  readonly target: string;
+  readonly message: string;
+}
+/** Controlled validation navigation; the application owns validation and submit timing. */
+export declare class VdFormErrorSummary {
+  readonly errors: import("@angular/core").InputSignal<readonly VdFormError[]>;
+  readonly title: import("@angular/core").InputSignal<string | undefined>;
+  readonly description: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    title: string;
+    description: string;
+  }, "title" | "description">>;
+  protected readonly titleId: string;
+  protected readonly descriptionId: string;
+  private readonly host;
+  private readonly injector;
+  private readonly destroyRef;
+  private scrollFrame;
+  constructor();
+  /** Call after a failed submit; passive updates deliberately do not move focus. */
+  focus(): void;
+  protected fragment(target: string): string;
+  protected navigate(event: MouseEvent, id: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdFormErrorSummary, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdFormErrorSummary, "vd-form-error-summary", never, {
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { VdFormError };