@vadem/ui 0.0.3 → 0.2.0

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

@@ -0,0 +1,222 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+/** Framework-agnostic board logic: validation, drop targets and immutable moves. */
+interface VdKanbanCardData {
+  readonly id: string;
+  /** Plain text used in announcements and the move menu's accessible name. */
+  readonly label: string;
+}
+interface VdKanbanColumn<T extends VdKanbanCardData = VdKanbanCardData> {
+  readonly id: string;
+  readonly title: string;
+  readonly cards: readonly T[];
+}
+/** A requested move. `toIndex` is the card's index in the target column after the move. */
+interface VdKanbanMove {
+  readonly cardId: string;
+  readonly fromColumnId: string;
+  readonly toColumnId: string;
+  readonly fromIndex: number;
+  readonly toIndex: number;
+  readonly method: 'menu' | 'pointer';
+}
+interface VdKanbanPosition {
+  readonly columnId: string;
+  readonly index: number;
+}
+/** Column and card IDs must be non-empty and unique across the whole board. */
+declare function vdKanbanValid(columns: readonly VdKanbanColumn[]): boolean;
+declare function vdKanbanFind(columns: readonly VdKanbanColumn[], cardId: string): VdKanbanPosition | null;
+/**
+ * Builds a move request, or null when it changes nothing or is out of range.
+ * `toIndex` is clamped to the target column (after removing the card from its source).
+ */
+declare function vdKanbanMoveRequest(columns: readonly VdKanbanColumn[], cardId: string, to: VdKanbanPosition, method: VdKanbanMove['method']): VdKanbanMove | null;
+/**
+ * Applies a move immutably: untouched columns keep their identity. Returns the same array when
+ * the move no longer matches the board (stale request), so callers can detect a no-op.
+ */
+export declare function vdKanbanApplyMove<T extends VdKanbanCardData, C extends VdKanbanColumn<T>>(columns: readonly C[], move: Pick<VdKanbanMove, 'cardId' | 'toColumnId' | 'toIndex'>): readonly C[];
+/**
+ * Insertion index for a pointer at `y` among the other cards of a column (the dragged card's own
+ * rectangle excluded): the number of cards whose vertical middle lies above the pointer.
+ */
+declare function vdKanbanInsertIndex(y: number, cards: readonly {
+  top: number;
+  bottom: number;
+}[]): number;
+/** The column under a horizontal pointer position, or -1 outside every column. */
+declare function vdKanbanColumnAt(x: number, columns: readonly {
+  left: number;
+  right: number;
+}[]): number;
+/** Template context for `ng-template[vdKanbanCard]` and `ng-template[vdKanbanColumnHeader]`. */
+interface VdKanbanCardContext<T extends VdKanbanCardData = VdKanbanCardData> {
+  $implicit: T;
+  column: VdKanbanColumn<T>;
+  index: number;
+}
+interface VdKanbanColumnContext<T extends VdKanbanCardData = VdKanbanCardData> {
+  $implicit: VdKanbanColumn<T>;
+}
+/** Card content. Without it, a card shows its `label`. */
+export declare class VdKanbanCard {
+  readonly template: TemplateRef<VdKanbanCardContext<VdKanbanCardData>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdKanbanCard, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdKanbanCard, "ng-template[vdKanbanCard]", never, {}, {}, never, never, true, never>;
+}
+/** Extra column header content after the title and count (for example a total). */
+export declare class VdKanbanColumnHeader {
+  readonly template: TemplateRef<VdKanbanColumnContext<VdKanbanCardData>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdKanbanColumnHeader, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<VdKanbanColumnHeader, "ng-template[vdKanbanColumnHeader]", never, {}, {}, never, never, true, never>;
+}
+interface Drop {
+  columnId: string;
+  index: number;
+  cardId: string | null;
+  edge: 'before' | 'after' | null;
+}
+/**
+ * A board of columns and cards. The application owns the data: the board never changes
+ * `columns` itself, it emits `cardMove` requests (from the Move menu or a pointer drag) and the
+ * application applies them (for example with `vdKanbanApplyMove`). Spec: specs/kanban.md
+ */
+export declare class VdKanban<T extends VdKanbanCardData = VdKanbanCardData> {
+  readonly columns: import("@angular/core").InputSignal<readonly VdKanbanColumn<T>[]>;
+  /** Disables every move (menus and dragging). Card content stays interactive. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly instructions: import("@angular/core").InputSignal<string | undefined>;
+  readonly emptyText: import("@angular/core").InputSignal<string | undefined>;
+  readonly invalidText: import("@angular/core").InputSignal<string | undefined>;
+  readonly countText: import("@angular/core").InputSignal<((count: number) => string) | undefined>;
+  readonly moveLabel: import("@angular/core").InputSignal<((card: string) => string) | undefined>;
+  readonly upText: import("@angular/core").InputSignal<string | undefined>;
+  readonly downText: import("@angular/core").InputSignal<string | undefined>;
+  readonly moveToText: import("@angular/core").InputSignal<string | undefined>;
+  readonly movedText: import("@angular/core").InputSignal<((card: string, column: string, position: number, total: number) => string) | undefined>;
+  readonly canceledText: import("@angular/core").InputSignal<((card: string) => string) | undefined>;
+  /** A move request. Apply it to `columns` to make it happen; ignore it to reject it. */
+  readonly cardMove: import("@angular/core").OutputEmitterRef<VdKanbanMove>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    instructions: string;
+    emptyText: string;
+    invalidText: string;
+    countText: (count: number) => string;
+    moveLabel: (card: string) => string;
+    upText: string;
+    downText: string;
+    moveToText: string;
+    movedText: (card: string, column: string, position: number, total: number) => string;
+    canceledText: (card: string) => string;
+  }, "label" | "instructions" | "emptyText" | "invalidText" | "countText" | "moveLabel" | "upText" | "downText" | "moveToText" | "movedText" | "canceledText">>;
+  protected readonly cardTemplate: import("@angular/core").Signal<VdKanbanCard | undefined>;
+  protected readonly columnHeader: import("@angular/core").Signal<VdKanbanColumnHeader | undefined>;
+  protected readonly valid: import("@angular/core").Signal<boolean>;
+  protected readonly baseId: string;
+  protected readonly instructionsId: string;
+  protected readonly draggingId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly drop: import("@angular/core").WritableSignal<Drop | null>;
+  protected readonly messages: import("@angular/core").WritableSignal<readonly {
+    serial: number;
+    text: string;
+  }[]>;
+  private readonly host;
+  private drag;
+  /** Card whose Move button should get focus once the moved card renders in its new place. */
+  private pendingFocus;
+  /** The click that follows a finished drag must not follow a link or activate content. */
+  private suppressClick;
+  private serial;
+  constructor();
+  protected moveTo(cardId: string, columnId: string, index: number): void;
+  private request;
+  protected start(event: PointerEvent, card: T): void;
+  protected pointerMove(event: PointerEvent): void;
+  protected end(event: PointerEvent): void;
+  protected pointerCancel(event: PointerEvent): void;
+  protected key(event: KeyboardEvent): void;
+  /** Lifts the card: a floating copy follows the pointer, the card itself becomes a slot. */
+  private activate;
+  /** Moves the floating copy, updates the drop marker and edge auto-scroll. */
+  private track;
+  /** Column and insertion index under the pointer, with the card that shows the marker. */
+  private target;
+  private finish;
+  private announce;
+  private cardElement;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdKanban<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdKanban<any>, "vd-kanban", never, {
+    "columns": {
+      "alias": "columns";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "instructions": {
+      "alias": "instructions";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalidText": {
+      "alias": "invalidText";
+      "required": false;
+      "isSignal": true;
+    };
+    "countText": {
+      "alias": "countText";
+      "required": false;
+      "isSignal": true;
+    };
+    "moveLabel": {
+      "alias": "moveLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "upText": {
+      "alias": "upText";
+      "required": false;
+      "isSignal": true;
+    };
+    "downText": {
+      "alias": "downText";
+      "required": false;
+      "isSignal": true;
+    };
+    "moveToText": {
+      "alias": "moveToText";
+      "required": false;
+      "isSignal": true;
+    };
+    "movedText": {
+      "alias": "movedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "canceledText": {
+      "alias": "canceledText";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "cardMove": "cardMove";
+  }, ["cardTemplate", "columnHeader"], never, true, never>;
+}
+export declare const VD_KANBAN: readonly [typeof VdKanban, typeof VdKanbanCard, typeof VdKanbanColumnHeader];
+export type { VdKanbanCardContext, VdKanbanCardData, VdKanbanColumn, VdKanbanColumnContext, VdKanbanMove, VdKanbanPosition };

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

@@ -121,6 +121,19 @@ interface VdLocale {
     title: string;
     description: string;
   };
+  kanban: {
+    label: string;
+    instructions: string;
+    emptyText: string;
+    invalidText: string;
+    countText: (count: number) => string;
+    moveLabel: (card: string) => string;
+    upText: string;
+    downText: string;
+    moveToText: string;
+    movedText: (card: string, column: string, position: number, total: number) => string;
+    canceledText: (card: string) => string;
+  };
   kbd: {
     thenLabel: string;
   };
@@ -164,6 +177,24 @@ interface VdLocale {
     movedText: (label: string, position: number, total: number) => string;
     canceledText: (label: string) => string;
   };
+  schedule: {
+    label: string;
+    todayText: string;
+    previousLabel: string;
+    nextLabel: string;
+    viewLabel: string;
+    monthText: string;
+    weekText: string;
+    dayText: string;
+    agendaText: string;
+    allDayText: string;
+    emptyText: string;
+    invalidText: string;
+    moreText: (count: number) => string;
+    eventsText: (count: number) => string;
+    changedText: (title: string, when: string) => string;
+    canceledText: (title: string) => string;
+  };
   searchInput: {
     clearLabel: string;
     loadingLabel: string;

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

@@ -0,0 +1,402 @@
+import * as i0 from "@angular/core";
+/**
+ * Framework-agnostic schedule logic. Times are local wall-clock strings without a time zone
+ * ("2026-10-21T14:30"): the application converts from its storage zone. All arithmetic runs on
+ * minutes counted as if UTC, so a day always has 1440 minutes and nothing shifts around DST.
+ */
+/** "YYYY-MM-DD" calendar date. */
+type VdIsoDate = string;
+type VdScheduleView = 'month' | 'week' | 'day' | 'agenda';
+type VdScheduleColor = 'accent' | 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+interface VdScheduleEvent {
+  readonly id: string;
+  readonly title: string;
+  /** Timed: "YYYY-MM-DDTHH:mm". All-day: "YYYY-MM-DD". */
+  readonly start: string;
+  /** Timed: exclusive end "YYYY-MM-DDTHH:mm". All-day: last day, inclusive, "YYYY-MM-DD". */
+  readonly end: string;
+  readonly allDay?: boolean;
+  readonly color?: VdScheduleColor;
+}
+/** A requested change of an event's time (from dragging or resizing). Same formats as the event. */
+interface VdScheduleEventChange {
+  readonly id: string;
+  readonly start: string;
+  readonly end: string;
+  readonly allDay: boolean;
+  readonly kind: 'move' | 'resize';
+}
+/** A normalized event: minutes since the epoch (wall clock), exclusive end. */
+interface VdScheduleItem<E extends VdScheduleEvent = VdScheduleEvent> {
+  readonly event: E;
+  readonly allDay: boolean;
+  readonly startMin: number;
+  readonly endMin: number;
+  /** First and last day the event touches (inclusive). */
+  readonly startDate: VdIsoDate;
+  readonly endDate: VdIsoDate;
+}
+declare const VD_DAY_MINUTES = 1440;
+/** Minutes since the epoch for "YYYY-MM-DD" (midnight) or "YYYY-MM-DDTHH:mm"; null if invalid. */
+declare function vdScheduleMinutes(value: string): number | null;
+declare function vdScheduleDateTime(minutes: number): string;
+declare function vdScheduleDate(minutes: number): VdIsoDate;
+/** Minutes since midnight of the day that contains `minutes`. */
+declare function vdScheduleTimeOfDay(minutes: number): number;
+declare function vdScheduleNormalize<E extends VdScheduleEvent>(event: E): VdScheduleItem<E> | null;
+/** IDs unique and non-empty; every event parses and ends after it starts. */
+declare function vdScheduleValid(events: readonly VdScheduleEvent[]): boolean;
+/** Normalized events sorted by start, all-day first, then longer first. */
+declare function vdScheduleItems<E extends VdScheduleEvent>(events: readonly E[]): VdScheduleItem<E>[];
+/** Items touching `date`. */
+declare function vdScheduleOnDay<E extends VdScheduleEvent>(items: readonly VdScheduleItem<E>[], date: VdIsoDate): VdScheduleItem<E>[];
+/** The dates a view shows for an anchor date. Month: 6 full weeks. */
+declare function vdScheduleDays(view: VdScheduleView, date: VdIsoDate, firstDay: number, agendaDays?: number): VdIsoDate[];
+/** The anchor date one period earlier or later. */
+declare function vdScheduleStep(view: VdScheduleView, date: VdIsoDate, direction: 1 | -1, agendaDays?: number): VdIsoDate;
+interface VdSchedulePlacement<E extends VdScheduleEvent = VdScheduleEvent> {
+  readonly item: VdScheduleItem<E>;
+  /** Minutes from the visible range start, clipped to the range. */
+  readonly top: number;
+  readonly bottom: number;
+  readonly column: number;
+  readonly columns: number;
+  /** The event continues before/after the visible part of this day. */
+  readonly clippedStart: boolean;
+  readonly clippedEnd: boolean;
+}
+/**
+ * Lays out the timed events of one day between `fromMinute` and `toMinute` (minutes after
+ * midnight). Overlapping events share the width: each cluster of transitively overlapping events
+ * gets the smallest number of columns and every event takes the first free column.
+ */
+declare function vdScheduleLayout<E extends VdScheduleEvent>(items: readonly VdScheduleItem<E>[], date: VdIsoDate, fromMinute?: number, toMinute?: number): VdSchedulePlacement<E>[];
+declare function vdScheduleSnap(minutes: number, step: number): number;
+/** Moves an event by whole days (all-day) or minutes (timed), keeping its duration. */
+declare function vdScheduleMove(item: VdScheduleItem, deltaMinutes: number): VdScheduleEventChange;
+/** Sets a timed event's end, keeping at least `minimum` minutes of duration. */
+declare function vdScheduleResize(item: VdScheduleItem, endMin: number, minimum: number): VdScheduleEventChange;
+/** Applies a change immutably; returns the same array when the event is not found. */
+export declare function vdScheduleApplyChange<E extends VdScheduleEvent>(events: readonly E[], change: VdScheduleEventChange): readonly E[];
+/** A click on empty space: a day (month) or a day and snapped time (week/day). */
+interface VdScheduleSlot {
+  readonly date: VdIsoDate;
+  /** "HH:mm", or null for a whole day. */
+  readonly time: string | null;
+}
+interface Preview {
+  change: VdScheduleEventChange;
+  item: VdScheduleItem;
+}
+/**
+ * Month, week, day and agenda views of application-owned events. The schedule never edits
+ * `events`: dragging or resizing emits `eventChange` requests that the application applies
+ * (for example with `vdScheduleApplyChange`). Spec: specs/schedule.md
+ */
+export declare class VdSchedule<E extends VdScheduleEvent = VdScheduleEvent> {
+  readonly events: import("@angular/core").InputSignal<readonly E[]>;
+  readonly view: import("@angular/core").ModelSignal<VdScheduleView>;
+  /** Any date inside the shown period ("YYYY-MM-DD"). Defaults to today. */
+  readonly date: import("@angular/core").ModelSignal<string>;
+  readonly views: import("@angular/core").InputSignal<readonly VdScheduleView[]>;
+  /** BCP 47 locale for names, week start, dates and times. Defaults to the app's LOCALE_ID. */
+  readonly locale: import("@angular/core").InputSignal<string>;
+  /** 0 = Sunday ... 6 = Saturday. Defaults to the locale's week start. */
+  readonly firstDayOfWeek: import("@angular/core").InputSignal<number | undefined>;
+  /** Visible hours in week/day views. */
+  readonly dayStartHour: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly dayEndHour: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Hour scrolled into view when a week/day view appears. */
+  readonly scrollToHour: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Snapping step for dragging, resizing and empty-slot clicks, in minutes. */
+  readonly slotMinutes: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly maxEventsPerDay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly agendaDays: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Current local time "YYYY-MM-DDTHH:mm" for the now line; omit to hide it. */
+  readonly now: import("@angular/core").InputSignal<string | null>;
+  /** Allows dragging and resizing (pointer). Activation and slot clicks always work. */
+  readonly editable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  readonly todayText: import("@angular/core").InputSignal<string | undefined>;
+  readonly previousLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly nextLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly viewLabel: import("@angular/core").InputSignal<string | undefined>;
+  readonly monthText: import("@angular/core").InputSignal<string | undefined>;
+  readonly weekText: import("@angular/core").InputSignal<string | undefined>;
+  readonly dayText: import("@angular/core").InputSignal<string | undefined>;
+  readonly agendaText: import("@angular/core").InputSignal<string | undefined>;
+  readonly allDayText: import("@angular/core").InputSignal<string | undefined>;
+  readonly emptyText: import("@angular/core").InputSignal<string | undefined>;
+  readonly invalidText: import("@angular/core").InputSignal<string | undefined>;
+  readonly moreText: import("@angular/core").InputSignal<((count: number) => string) | undefined>;
+  readonly eventsText: import("@angular/core").InputSignal<((count: number) => string) | undefined>;
+  readonly changedText: import("@angular/core").InputSignal<((title: string, when: string) => string) | undefined>;
+  readonly canceledText: import("@angular/core").InputSignal<((title: string) => string) | undefined>;
+  /** An event was clicked or activated with the keyboard (open it, edit it...). */
+  readonly eventActivate: import("@angular/core").OutputEmitterRef<E>;
+  /** Empty space was clicked (create an event there). */
+  readonly slotActivate: import("@angular/core").OutputEmitterRef<VdScheduleSlot>;
+  /** A drag or resize asks to change an event's time. Apply it to `events` or ignore it. */
+  readonly eventChange: import("@angular/core").OutputEmitterRef<VdScheduleEventChange>;
+  protected readonly t: import("@angular/core").Signal<Pick<{
+    label: string;
+    todayText: string;
+    previousLabel: string;
+    nextLabel: string;
+    viewLabel: string;
+    monthText: string;
+    weekText: string;
+    dayText: string;
+    agendaText: string;
+    allDayText: string;
+    emptyText: string;
+    invalidText: string;
+    moreText: (count: number) => string;
+    eventsText: (count: number) => string;
+    changedText: (title: string, when: string) => string;
+    canceledText: (title: string) => string;
+  }, "label" | "todayText" | "previousLabel" | "nextLabel" | "viewLabel" | "monthText" | "weekText" | "dayText" | "agendaText" | "allDayText" | "emptyText" | "invalidText" | "moreText" | "eventsText" | "changedText" | "canceledText">>;
+  protected readonly baseId: string;
+  protected readonly today: import("@angular/core").Signal<string>;
+  protected readonly valid: import("@angular/core").Signal<boolean>;
+  protected readonly items: import("@angular/core").Signal<VdScheduleItem<E>[]>;
+  protected readonly firstDay: import("@angular/core").Signal<number>;
+  protected readonly days: import("@angular/core").Signal<string[]>;
+  protected readonly weeks: import("@angular/core").Signal<string[][]>;
+  protected readonly weekdays: import("@angular/core").Signal<{
+    short: string;
+    long: string;
+  }[]>;
+  protected readonly hours: import("@angular/core").Signal<number[]>;
+  /** Month cells: visible events and the overflow count per day. */
+  protected readonly month: import("@angular/core").Signal<Map<string, {
+    visible: VdScheduleItem<E>[];
+    more: number;
+  }>>;
+  protected readonly layout: import("@angular/core").Signal<Map<string, VdSchedulePlacement<E>[]>>;
+  protected readonly agenda: import("@angular/core").Signal<{
+    date: string;
+    items: VdScheduleItem<E>[];
+  }[]>;
+  protected readonly title: import("@angular/core").Signal<string>;
+  protected readonly focusDate: import("@angular/core").WritableSignal<string>;
+  protected readonly draggingId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly preview: import("@angular/core").WritableSignal<Preview | null>;
+  protected readonly messages: import("@angular/core").WritableSignal<readonly {
+    serial: number;
+    text: string;
+  }[]>;
+  private readonly host;
+  private drag;
+  private moveFocus;
+  private suppressClick;
+  private serial;
+  private scrolledView;
+  constructor();
+  protected goToday(): void;
+  protected step(direction: 1 | -1): void;
+  protected openDay(date: VdIsoDate): void;
+  private monthKey;
+  protected activate(event: E): void;
+  /**
+   * Pointer convenience on empty space (keyboard users create events with the application's own
+   * controls): a month cell or all-day cell gives a day, a time-grid column a snapped time.
+   */
+  protected emptyClick(event: MouseEvent): void;
+  private slotClick;
+  protected dragStart(event: PointerEvent, item: VdScheduleItem<E>, kind: 'move' | 'resize'): void;
+  protected dragMove(event: PointerEvent): void;
+  protected dragEnd(event: PointerEvent): void;
+  protected dragCancel(event: PointerEvent): void;
+  protected key(event: KeyboardEvent): void;
+  /** The change a pointer position asks for, or null when it changes nothing. */
+  private changeAt;
+  /** Date (and minute in time grids) under a viewport point. */
+  private pointAt;
+  /** Minute of the day for a y position inside a time-grid column. */
+  private minuteAt;
+  private finish;
+  /** Dashed preview of a timed change inside a time-grid column. */
+  protected ghost(day: VdIsoDate): {
+    top: number;
+    span: number;
+    startMin: number;
+  } | null;
+  protected nowLine(day: VdIsoDate): number | null;
+  protected allDay(day: VdIsoDate): VdScheduleItem<E>[];
+  protected viewText(view: VdScheduleView): string;
+  protected sameMonth(day: VdIsoDate): boolean;
+  protected dayNumber(day: VdIsoDate): string;
+  protected weekdayShort(day: VdIsoDate): string;
+  protected longDate(day: VdIsoDate): string;
+  protected dayLabel(day: VdIsoDate): string;
+  protected time(minutes: number): string;
+  protected hourLabel(hour: number): string;
+  /** Time range shown for an event on a given day ("All day" for all-day events). */
+  protected rangeText(item: VdScheduleItem, day: VdIsoDate): string;
+  protected eventLabel(item: VdScheduleItem): string;
+  private whenText;
+  private clock;
+  private slot;
+  private announce;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VdSchedule<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VdSchedule<any>, "vd-schedule", never, {
+    "events": {
+      "alias": "events";
+      "required": false;
+      "isSignal": true;
+    };
+    "view": {
+      "alias": "view";
+      "required": false;
+      "isSignal": true;
+    };
+    "date": {
+      "alias": "date";
+      "required": false;
+      "isSignal": true;
+    };
+    "views": {
+      "alias": "views";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "firstDayOfWeek": {
+      "alias": "firstDayOfWeek";
+      "required": false;
+      "isSignal": true;
+    };
+    "dayStartHour": {
+      "alias": "dayStartHour";
+      "required": false;
+      "isSignal": true;
+    };
+    "dayEndHour": {
+      "alias": "dayEndHour";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollToHour": {
+      "alias": "scrollToHour";
+      "required": false;
+      "isSignal": true;
+    };
+    "slotMinutes": {
+      "alias": "slotMinutes";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxEventsPerDay": {
+      "alias": "maxEventsPerDay";
+      "required": false;
+      "isSignal": true;
+    };
+    "agendaDays": {
+      "alias": "agendaDays";
+      "required": false;
+      "isSignal": true;
+    };
+    "now": {
+      "alias": "now";
+      "required": false;
+      "isSignal": true;
+    };
+    "editable": {
+      "alias": "editable";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "todayText": {
+      "alias": "todayText";
+      "required": false;
+      "isSignal": true;
+    };
+    "previousLabel": {
+      "alias": "previousLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nextLabel": {
+      "alias": "nextLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "viewLabel": {
+      "alias": "viewLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "monthText": {
+      "alias": "monthText";
+      "required": false;
+      "isSignal": true;
+    };
+    "weekText": {
+      "alias": "weekText";
+      "required": false;
+      "isSignal": true;
+    };
+    "dayText": {
+      "alias": "dayText";
+      "required": false;
+      "isSignal": true;
+    };
+    "agendaText": {
+      "alias": "agendaText";
+      "required": false;
+      "isSignal": true;
+    };
+    "allDayText": {
+      "alias": "allDayText";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalidText": {
+      "alias": "invalidText";
+      "required": false;
+      "isSignal": true;
+    };
+    "moreText": {
+      "alias": "moreText";
+      "required": false;
+      "isSignal": true;
+    };
+    "eventsText": {
+      "alias": "eventsText";
+      "required": false;
+      "isSignal": true;
+    };
+    "changedText": {
+      "alias": "changedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "canceledText": {
+      "alias": "canceledText";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "view": "viewChange";
+    "date": "dateChange";
+    "eventActivate": "eventActivate";
+    "slotActivate": "slotActivate";
+    "eventChange": "eventChange";
+  }, never, never, true, never>;
+}
+export type { VdIsoDate, VdScheduleColor, VdScheduleEvent, VdScheduleEventChange, VdScheduleSlot, VdScheduleView };

package/types/vadem-ui.d.ts

@@ -1 +1 @@
-export declare const VD_VERSION = "0.0.3";
+export declare const VD_VERSION = "0.2.0";