@alfadocs/ui-kit 1.37.0 → 1.39.0

package/dist/patterns/calendar/calendar-appointment-details.sections.d.ts

@@ -6,9 +6,9 @@ interface CardProps {
 }
 /**
  * The kit's PatientSummaryCard: identity, the attention chips, the money
- * chips and the contact fields. Signing and anamnesis explain themselves
- * in the chips' hover cards; money reads worst first (owed, to invoice,
- * paid online), labelled and without glyphs.
+ * chips and the contact fields. Every chip explains itself in a hover
+ * card; money reads worst first (owed, to invoice, paid online), labelled
+ * and without glyphs.
  */
 export declare function DetailsPatientCard({ details, locale, mapsLink, }: CardProps & {
     /** The user's map-link setting (platform `showPatientAddressMapLink`). */
@@ -20,13 +20,18 @@ export declare function DetailsPatientCard({ details, locale, mapsLink, }: CardP
  * an id the data does not know prints no row. `description` is the host's
  * slot for the description, above the facts.
  */
-export declare function DetailsAppointmentCard({ details, locale, description, }: CardProps & {
+export declare function DetailsAppointmentCard({ details, locale, description, privacy, }: CardProps & {
     description?: ReactNode;
+    /** Privacy mode: what the booker typed is dropped; when they booked stays. */
+    privacy?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
 /** The linked plan, by number when the host has one, and the kit's
  *  TreatmentReceipt: one line per treatment, a price only when the host
  *  sends one (the editor's price gate), and a total only when every line
  *  is priced. */
-export declare function DetailsTreatmentsCard({ details, locale }: CardProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DetailsTreatmentsCard({ details, locale, privacy, }: CardProps & {
+    /** Privacy mode: the plan's free-text name goes, as on the hover peek. */
+    privacy?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
 export {};
 //# sourceMappingURL=calendar-appointment-details.sections.d.ts.map

package/dist/patterns/calendar/calendar-bookings-panel.d.ts

@@ -0,0 +1,31 @@
+import type { CalendarRow } from './calendar.model';
+import { type BookingRowView } from './calendar-workspace.model';
+/** Which half of the booking the user asked to complete: a hint for the
+ *  host editor's landing step. Absent means the plain "edit" entry. */
+export type BookingCompleteIntent = 'patient' | 'operator';
+/**
+ * The digits `wa.me` needs from the SMS-verified booking number, or null.
+ * A host may hand over a redacted display value ("+39 *** 121"): anything
+ * but a plain number is refused rather than turned into a wrong chat.
+ */
+export declare function bookingWhatsAppDigits(phone: string | undefined): string | null;
+export interface BookingCardProps {
+    view: BookingRowView;
+    locale?: string;
+    /** Masked title, no photo, no contact, no reason, no WhatsApp number. */
+    privacy?: boolean;
+    /** False withholds the assign segments and the pencil: a host that cannot
+     *  complete a booking is never offered a control it would refuse. */
+    canComplete: boolean;
+    onComplete?: (row: CalendarRow, intent?: BookingCompleteIntent) => void;
+    onShowInCalendar: (eventId: string) => void;
+    /** The host addressed this card: ring it (see `BookingsPanel`). */
+    addressed?: boolean;
+    /** Changes on every address, so a repeat address replays the ring. */
+    addressKey?: string | number;
+}
+export declare const BookingCard: import("react").ForwardRefExoticComponent<BookingCardProps & import("react").RefAttributes<HTMLDivElement>>;
+/** The first read's placeholders, in the card's own shape: time block,
+ *  avatar, three lines, and the strip under its divider. */
+export declare function BookingCardsSkeleton(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=calendar-bookings-panel.d.ts.map

package/dist/patterns/calendar/calendar-editor-hydration.d.ts

@@ -44,8 +44,6 @@ export type CalendarAppointmentEditorLoader = (eventId: string, options: {
 type ReadySnapshot = Extract<CalendarAppointmentEditorSnapshot, {
     status: 'ready';
 }>;
-/** The editor is not mounted until the host returns its canonical data.
- * Mounting this boundary per open also reloads a previously closed editor. */
 export declare function CalendarEditorHydration({ eventId, load, onCancel, children, }: {
     eventId?: string;
     load?: CalendarAppointmentEditorLoader;

package/dist/patterns/calendar/calendar-info-hover.d.ts

@@ -2,7 +2,8 @@
  * The hover card body the details panel's chips share: an eyebrow naming
  * the kind of thing, a heading restating the chip in words, and the facts
  * the chip could not fit. Ported from the calendar-rail demo's hover
- * grammar; `PatientSummaryCard.flagHover` renders it around its own chip.
+ * grammar; `PatientSummaryCard.flagHover` renders it around its own chip,
+ * and `InfoHover` wraps the chips the panel renders itself.
  */
 import type { ReactNode } from 'react';
 export interface InfoHoverFact {
@@ -15,4 +16,17 @@ export declare function InfoHoverBody({ eyebrow, heading, facts, }: {
     heading: string;
     facts?: readonly InfoHoverFact[];
 }): ReactNode;
+/**
+ * Wraps a chip the panel renders itself in the same card. It carries no
+ * open button: the pattern has no seam to open invoicing or the anamnesis.
+ */
+export declare function InfoHover({ id, eyebrow, heading, facts, children, }: {
+    /** Stamped as `data-chip-hover`, the trigger's DOM hook. */
+    id: string;
+    eyebrow: string;
+    heading: string;
+    facts?: readonly InfoHoverFact[];
+    /** The chip; its visible text is the trigger's accessible name. */
+    children: ReactNode;
+}): ReactNode;
 //# sourceMappingURL=calendar-info-hover.d.ts.map

package/dist/patterns/calendar/calendar-privacy.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+/** The mask privacy mode shows for a name. TOTAL, as `maskedTitle` is: an
+ *  empty or absent host mask degrades to the bullets, never to a blank. */
+export declare function privacyMask(mask?: string): string;
+/** One muted line where a personal value would have been. */
+export declare function PrivacyHiddenLine({ block }: {
+    block?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** The patient card under privacy: the grid's mask, no photo, no contact
+ *  fields and no chips. Keeps `data-card="patient"` for host hooks. */
+export declare function PrivacyIdentityCard({ mask }: {
+    mask?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** A whole rail panel withheld under privacy: a form or a notes list that
+ *  could only open by showing what the mask hides. */
+export declare function PrivacyNoticePanel({ title, icon, onTurnOff, }: {
+    /** The panel's own title, so the rail still says which tool this is. */
+    title: string;
+    icon?: ReactNode;
+    /** Absent: the notice explains, and the toolbar's toggle is the way out. */
+    onTurnOff?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=calendar-privacy.d.ts.map

package/dist/patterns/calendar/calendar-rail-settle.d.ts

@@ -0,0 +1,14 @@
+import { type RefObject } from 'react';
+import type { EditorInitialFocus } from './calendar.model';
+/**
+ * Runs `run` once the node's rail entrance has settled, so a focus scroll
+ * never fights the motion. A node that is absent is a silent no-op.
+ * Returns the cancel.
+ */
+export declare function whenRailSettled(getNode: () => HTMLElement | null | undefined, run: (node: HTMLElement) => void): () => void;
+/**
+ * Lands the editor on one field once its panel has settled. No field, an
+ * absent field or a disabled one leaves focus where it was, silently.
+ */
+export declare function useEditorInitialFocus(field: EditorInitialFocus | undefined, fields: Record<EditorInitialFocus, RefObject<HTMLElement | null>>): void;
+//# sourceMappingURL=calendar-rail-settle.d.ts.map

package/dist/patterns/calendar/calendar-upcoming-panel.d.ts

@@ -0,0 +1,32 @@
+import { Clock } from 'lucide-react';
+import type { CalendarRow } from './calendar.model';
+export interface UpcomingAppointmentsPanelProps {
+    rows: CalendarRow[];
+    locale: string;
+    /** Privacy mode masks every name in the strip, the band and the list — a
+     *  clinic-wide "who is here / who is coming in" is exactly what it hides. */
+    privacy: boolean;
+    /** Selects the appointment on the grid, which docks its details. */
+    onOpenAppointment: (eventId: string) => void;
+    /**
+     * `DoctorAppointment.lastStateUpdate`, keyed by appointment id, for rows
+     * the live band shows. Optional: the platform read model does not carry
+     * this field yet (see `calendar.sheets` note above the panel), and a row
+     * missing from this map shows its state with no elapsed time rather than
+     * one derived from its start time or invented.
+     */
+    stateSinceByEventId?: Readonly<Record<string, string>>;
+    /**
+     * The host is still fetching rows. Shows content-shaped Skeleton
+     * placeholders instead of the list, `aria-busy="true"`, and no spinner
+     * or "Loading…" text. A refresh (rows already present) keeps the old
+     * rows on screen instead of blanking them — pass `loading` only for the
+     * first read.
+     */
+    loading?: boolean;
+}
+export declare function UpcomingAppointmentsPanel({ rows, locale, privacy, onOpenAppointment, stateSinceByEventId, loading, }: UpcomingAppointmentsPanelProps): import("react/jsx-runtime").JSX.Element;
+/** Icon re-export so callers that only need the panel's own glyph (e.g. a
+ *  rail tool registration) don't have to import lucide-react directly. */
+export { Clock as UpcomingAppointmentsPanelIcon };
+//# sourceMappingURL=calendar-upcoming-panel.d.ts.map

package/dist/patterns/calendar/calendar-waiting-list-panel.d.ts

@@ -0,0 +1,62 @@
+import { type CalendarRow, type WaitingEntryDraft } from './calendar.model';
+import { type WaitingListRowView } from './calendar-workspace.model';
+import { type CalendarPatient, type CalendarWaitingEntry } from './calendar.types';
+export interface WaitingEntryCardProps {
+    view: WaitingListRowView;
+    locale: string;
+    privacy?: boolean;
+    readOnly?: boolean;
+    /** Schedule (unlinked) / Bring forward (linked). */
+    onPlace: (entry: CalendarWaitingEntry) => void;
+    /** Unset = no finder on this host: the button is not rendered. */
+    onFindSlots?: (entry: CalendarWaitingEntry) => void;
+    /** Unset = no entry form on this host: Edit and Assign are withheld. */
+    onEdit?: (entry: CalendarWaitingEntry) => void;
+    onRemove: (entry: CalendarWaitingEntry) => void;
+    onOpenPatient?: (patient: CalendarPatient) => void;
+    onOpenAppointment: (eventId: string) => void;
+}
+/** A waiting entry as one elevated card: who, since when, what it is
+ *  tied to, and the one line of actions that moves it off the list. */
+export declare const WaitingEntryCard: import("react").ForwardRefExoticComponent<WaitingEntryCardProps & import("react").RefAttributes<HTMLElement>>;
+export interface WaitingListPanelProps {
+    /** Privacy mode, in step with the grid: names masked, the photo, the
+     *  phone, the WhatsApp link and the free-text description withheld. */
+    privacy?: boolean;
+    entries: CalendarWaitingEntry[];
+    /** Live grid rows — the linked appointment's date, colour and care. */
+    rows: CalendarRow[];
+    locale: string;
+    /** No edit permission (`permissions.editAppointment === false`). Add,
+     *  Edit, Assign and Remove are withheld and a lock note says why. */
+    readOnly?: boolean;
+    /** The host's read of the queue. A first `loading` shows card-shaped
+     *  placeholders; a refresh keeps its cards and marks the list busy. */
+    status?: 'loading' | 'ready' | 'error';
+    onRetry?: () => void;
+    /** Schedule / Bring forward → the host's placement hand-off. */
+    onPlaceWaiting: (entry: CalendarWaitingEntry) => void;
+    /** «Find a slot» → the find-slots tool, seeded by the host from the
+     *  entry (`FindSlotsSeed`). Unset = the button is not rendered. */
+    onFindSlotsForWaiting?: (entry: CalendarWaitingEntry) => void;
+    /** Delete — immediate, as on the platform (the host toasts an Undo). */
+    onRemoveWaiting: (entry: CalendarWaitingEntry) => void;
+    /** Add entry, a row's edit and the assign buttons → the entry form. */
+    onOpenEntryForm?: (entry?: CalendarWaitingEntry) => void;
+    /**
+     * The entry form as a `PanelSubview` over this list. Pass the open
+     * state (`null` = closed) with `onSaveEntry` and `onCancelEntry`; leave
+     * all three out and the host renders its own form, as before.
+     */
+    entryForm?: {
+        entry?: CalendarWaitingEntry;
+    } | null;
+    onSaveEntry?: (draft: WaitingEntryDraft) => void;
+    onCancelEntry?: () => void;
+    /** The patient-folder hop. Unset renders the name as plain text. */
+    onOpenPatient?: (patient: CalendarPatient) => void;
+    /** The platform's `focusAppointmentId` deep link — steer and ring. */
+    onOpenAppointment: (eventId: string) => void;
+}
+export declare const WaitingListPanel: import("react").ForwardRefExoticComponent<WaitingListPanelProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=calendar-waiting-list-panel.d.ts.map

package/dist/patterns/calendar/calendar-workspace.d.ts

@@ -4,7 +4,7 @@ import { type CalendarData } from './calendar.data';
 import type { CalendarJourney } from './calendar.journey';
 import { type CalendarPreferenceAdapter } from './calendar.preferences';
 import { type CalendarRow, type EditorPrefill } from './calendar.model';
-import { type CalendarWorkspaceToolId, type WorkspaceDisplaySettings } from './calendar-workspace.model';
+import { type CalendarWaitingListState, type CalendarWorkspaceToolId, type WorkspaceDisplaySettings } from './calendar-workspace.model';
 export { WORKSPACE_TOOL, type CalendarWorkspaceToolId, } from './calendar-workspace.model';
 /** Host-owned queue membership, independent of the visible calendar range. */
 export interface CalendarOnlineBookings {
@@ -34,6 +34,13 @@ export interface CalendarWorkspaceProps {
     data: CalendarData;
     /** Supplied rows are authoritative, including an explicitly empty queue. */
     onlineBookings?: CalendarOnlineBookings;
+    /** The host's read of the waiting list: a first `loading` shows
+     *  placeholders, `error` offers `onRetry`. Omitted = always ready. */
+    waitingListState?: CalendarWaitingListState;
+    /** When each appointment entered its current state, by event id (ISO
+     *  8601). The upcoming panel shows "waiting for 12 min" only for rows
+     *  listed here; it never derives an elapsed time from the start. */
+    stateSinceByEventId?: Readonly<Record<string, string>>;
     locale?: string;
     /** Host-level cog overrides. */
     initialDisplay?: Partial<WorkspaceDisplaySettings>;
@@ -45,6 +52,12 @@ export interface CalendarWorkspaceProps {
     /** Deep link `focusAppointmentId`: open on the appointment's day, ring
      *  and scroll to its card and dock its details. */
     focusAppointmentId?: string;
+    /** Addresses one online booking: docks the bookings tool, then scrolls
+     *  to, focuses and rings its card. An id outside the queue rings nothing. */
+    focusBookingId?: string;
+    /** Bump to address the SAME booking again (a second notification): an
+     *  address is a request, not a value. */
+    focusBookingKey?: string | number;
     /** Deep link `createParameters`: arrive in CREATE mode — the banner
      *  stands and the next free-slot click opens the editor prefilled. */
     createParameters?: {

package/dist/patterns/calendar/calendar-workspace.model.d.ts

@@ -295,7 +295,17 @@ export declare const UPCOMING_STEP_DAYS = 7;
 /** Where the widening stops — the demo's own ceiling, not the platform's. */
 export declare const UPCOMING_MAX_DAYS = 180;
 export declare const DEFAULT_UPCOMING_WINDOW: UpcomingWindow;
-/** Epoch bounds of a window, inclusive of its closing second. */
+/**
+ * Epoch bounds of a window, inclusive of its closing second.
+ *
+ * The start always lands on a day boundary — midnight of
+ * `nowIso - backDays` — never at the exact instant of `now`. At rest
+ * (`backDays: 0`) that means "the beginning of today", not "this second":
+ * a row that has already started (waiting room, in the chair) stays in
+ * the window instead of disappearing the moment it begins. Widening
+ * (`widenUpcomingWindow('earlier', …)`) reaches further back a whole day
+ * at a time from that same floor.
+ */
 export declare function upcomingWindowBounds(nowIso: string, window: UpcomingWindow): {
     startMs: number;
     endMs: number;
@@ -410,6 +420,9 @@ export interface WaitingListRowView {
     operatorTitle?: string;
     /** Platform `appointmentName` — the linked appointment's care line. */
     appointmentName?: string;
+    /** The row's one photo: the resolved patient record's, else the
+     *  entry's own `patientAvatarUrl`. Absent = initials. */
+    avatarSrc?: string;
     /** Someone is booked on this row — the entry's own patient or the
      *  linked appointment's. Keyed on the IDS: a record we could not load
      *  is still a patient. */
@@ -426,4 +439,27 @@ export declare function waitingEntryMatchesFilters(view: WaitingListRowView, fil
 /** The quick view first, then the advanced predicates — the platform's
  *  own order (`_filterForAdvancedSearch` re-runs the view). */
 export declare function filterWaitingEntries(entries: readonly CalendarWaitingEntry[], rows: readonly CalendarRow[], quickView: WaitingQuickView, filters: WaitingListFilters, data: CalendarData): WaitingListRowView[];
+/** What an entry is FOR. The domain allows exactly one connection, so
+ *  the test is a precedence, and an entry never lands in two groups. */
+export type WaitingEntryKind = 'linked' | 'patient' | 'memo';
+/** Render order: bring forward, first slot, free-text reminders. */
+export declare const WAITING_ENTRY_KINDS: readonly WaitingEntryKind[];
+/** Keyed on the IDS, never on what resolved: an appointment off the
+ *  loaded range is still a link, an unloaded patient still a patient. */
+export declare function waitingEntryKind(entry: CalendarWaitingEntry): WaitingEntryKind;
+/** The non-empty groups, in render order, rows in queue order. */
+export declare function groupWaitingRows(views: readonly WaitingListRowView[]): {
+    kind: WaitingEntryKind;
+    rows: WaitingListRowView[];
+}[];
+/** How many entries each quick view holds, from the rows in hand. */
+export declare function waitingQuickViewCounts(entries: readonly CalendarWaitingEntry[], data: CalendarData): Record<WaitingQuickView, number>;
+/** The number WhatsApp may be handed, `''` when there is none. The host's
+ *  own `whatsappPhoneNumber` wins; the story flag reads the record. */
+export declare function waitingWhatsAppNumber(view: WaitingListRowView): string;
+/** A host's read of the queue, so the panel can show a first load. */
+export interface CalendarWaitingListState {
+    status: 'loading' | 'ready' | 'error';
+    onRetry?: () => void;
+}
 //# sourceMappingURL=calendar-workspace.model.d.ts.map

package/dist/patterns/calendar/calendar.model.d.ts

@@ -29,8 +29,8 @@ export interface CalendarRow {
     careLink?: CalendarCareLink;
 }
 /**
- * A drag/resize of a PATIENT appointment awaiting confirmation (ported
- * from the appointment-workflow pattern's move-confirm design). Rows stay
+ * A drag/resize of a PATIENT appointment awaiting confirmation (the
+ * retired appointment-workflow pattern's move-confirm design). Rows stay
  * UN-mutated while the dialog is open, so the OLD end/chair/operator are
  * read live from the matching `CalendarRow`; `event` is FullCalendar's
  * post-drop snapshot and already carries the NEW resourceId.
@@ -148,6 +148,8 @@ export interface CalendarEditorCapabilities {
     /** False disables the status control and omits status from the draft. */
     editStatus?: boolean;
 }
+/** The editor field an arrival lands focus on. */
+export type EditorInitialFocus = 'patient' | 'operator';
 export interface EditorPrefill {
     /** Set = the editor EDITS this existing event; unset = create. */
     editEventId?: string;
@@ -183,6 +185,10 @@ export interface EditorPrefill {
      *  somewhere to go back to — splits Save into "save and go back" and
      *  "save and continue"; anything else keeps the one Save. */
     simpleSave?: boolean;
+    /** Lands focus on this field once the panel has settled (a booking's
+     *  assign intent). A hint, never saved: an absent or disabled field, or
+     *  no value, moves no focus. */
+    initialFocus?: EditorInitialFocus;
 }
 /** Platform's six `recurrence_frequency` values, in its dropdown order. */
 export type RecurrenceFrequency = 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'semiannual' | 'yearly';

package/dist/patterns/calendar/calendar.sheets.d.ts

@@ -24,11 +24,31 @@
 import { type ReactNode } from 'react';
 import type { CalendarEditorCapabilities } from './calendar.model';
 import type { CalendarEditorSeries } from './calendar-editor-hydration';
-import { type CalendarEvent } from '../../components/calendar';
+import { type CalendarEvent, type CalendarResource } from '../../components/calendar';
 import { type NotesPanelNote, type NotesPanelProps, type NotesPanelSubmission } from '../../components/notes-panel';
 import { type ColorAssociation, type CalendarCarePlan, type CalendarAnamnesisAnswer, type CalendarOperatorGroup, type CalendarPatient, type CalendarWaitingEntry, type CalendarHistoryEntry, type CalendarSignChannel, type PatientRef } from './calendar.types';
+import { type CalendarData } from './calendar.data';
 import { type CalendarRow, type DisplaySettings, type EditorPrefill, type EditorDraft, type DraftSlot, type SlotPatch, type BacklogFilter, type BacklogItem, type WaitingEntryDraft, type CalendarFreeSlot, type PrintDaySection, type FindSlotsSeed, type AvailabilityContext } from './calendar.model';
 import { type EditorDraftExtras, type DeleteOptions } from './calendar-workspace.model';
+import { type BookingCompleteIntent } from './calendar-bookings-panel';
+/** The operators a NEW booking may take — the practice's ACTIVE cast, as
+ *  on the platform. A disabled operator reaches a list only through
+ *  `platform.operatorOptions` (the appointment that already holds her);
+ *  lookups by id stay inclusive so her own rows still name her. */
+export declare function activeOperators(data: CalendarData): CalendarResource[];
+/** Why the WhatsApp affordance cannot act, as an i18n key. Decided in ONE
+ *  place so the waiting list's two rows — the backlog card and the grid
+ *  cell — cannot drift apart again.
+ *
+ *  Three states, never two (see `patientChannelState`). `unknown` folds
+ *  "no record at all" together with "a record that omits the number", so
+ *  a caller reading it as "no record" told a patient the row had just
+ *  rendered by name that their record had failed to load. Only
+ *  `ref.unresolved` — the lookup we really did fail — may say that; a
+ *  record we DID load and that simply carries no number says so itself,
+ *  and never claims the practice holds nothing (that is state `none`,
+ *  which keeps the platform's own SMS reason). */
+export declare function whatsAppUnavailableKey(ref: PatientRef): string;
 export declare function TaskDetailsPanel({ row, locale, }: {
     row: CalendarRow;
     locale: string;
@@ -340,7 +360,7 @@ export declare function BacklogPanel({ items, locale, seed, signRequests, onProc
      *  mode (create / move banner) instead of opening the editor at once. */
     onPlaceWaiting?: (entry: CalendarWaitingEntry) => void;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function BookingsPanel({ bookings, locale, privacy, status, lastSeenIso, createdAtById, onRetry, onShowInCalendar, onComplete, }: {
+export declare function BookingsPanel({ bookings, locale, privacy, status, lastSeenIso, createdAtById, currentBookingId, currentBookingKey, onRetry, onShowInCalendar, onComplete, }: {
     bookings: readonly CalendarRow[];
     locale?: string;
     /** Masks the patient names, in step with the grid. */
@@ -348,34 +368,18 @@ export declare function BookingsPanel({ bookings, locale, privacy, status, lastS
     status?: 'loading' | 'ready' | 'error';
     lastSeenIso?: string | null;
     createdAtById?: Readonly<Record<string, string>>;
+    /** The booking the host is addressing: scrolled to, focused, and ringed
+     *  in the accent until the ring settles. Unknown ids are ignored. */
+    currentBookingId?: string;
+    /** Bump on every address, so the SAME booking addressed twice scrolls,
+     *  focuses and rings again. An address is a request, not a value. */
+    currentBookingKey?: string | number;
     onRetry?: () => void;
     /** Steers the grid to the booking and rings its card. */
     onShowInCalendar: (eventId: string) => void;
-    /** Opens the editor to complete it (platform "Completa appuntamento"). */
-    onComplete?: (row: CalendarRow) => void;
-}): import("react/jsx-runtime").JSX.Element;
-export declare function WaitingListPanel({ entries, rows, locale, onPlaceWaiting, onRemoveWaiting, onOpenEntryForm, onOpenPatient, onOpenAppointment, readOnly, }: {
-    entries: CalendarWaitingEntry[];
-    /** Live grid rows — the linked appointment's date, colour and care. */
-    rows: CalendarRow[];
-    locale: string;
-    /** No edit permission (`permissions.editAppointment === false`). Add,
-     *  Edit and Remove are withheld and a lock note says why: each one
-     *  calls a host seam that a read-only host silently refuses, and the
-     *  panel would then have announced a change it never made. */
-    readOnly?: boolean;
-    /** Schedule / Reschedule → the host's create / move placement mode. */
-    onPlaceWaiting: (entry: CalendarWaitingEntry) => void;
-    /** Delete — immediate, as on the platform (the host toasts an Undo). */
-    onRemoveWaiting: (entry: CalendarWaitingEntry) => void;
-    /** Add entry, and a row's edit → the host's entry sub-view. */
-    onOpenEntryForm: (entry?: CalendarWaitingEntry) => void;
-    /** The patient-folder hop the platform's name link makes. Unset — a
-     *  host with no folder to route to — renders the name as plain text
-     *  rather than a link that cannot arrive anywhere. */
-    onOpenPatient?: (patient: CalendarPatient) => void;
-    /** The platform's `focusAppointmentId` deep link — steer and ring. */
-    onOpenAppointment: (eventId: string) => void;
+    /** Opens the editor to complete it (platform "Completa appuntamento").
+     *  `intent` says which assign segment was pressed; the pencil sends none. */
+    onComplete?: (row: CalendarRow, intent?: BookingCompleteIntent) => void;
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * The platform's waiting-list AddModal as a rail sub-view — same field
@@ -395,6 +399,18 @@ export declare function WaitingListEntryForm({ entry, onSave, onCancel, chrome,
      *  the form's Cancel already dismiss it. */
     chrome?: 'panel' | 'dialog';
 }): import("react/jsx-runtime").JSX.Element;
+/**
+ * The same entry form as a `PanelSubview`: it slides over the queue it was
+ * opened from, pins Cancel and Save, and hands focus back to the opener.
+ */
+export declare function WaitingListEntrySubview({ open, entry, onSave, onCancel, readOnly, }: {
+    open: boolean;
+    /** Set = edit this entry; unset = add a new one. */
+    entry?: CalendarWaitingEntry;
+    onSave: (draft: WaitingEntryDraft) => void;
+    onCancel: () => void;
+    readOnly?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
 /**
  * The call sheet itself. A portal to `document.body`: the shell's AppFrame
  * is an `h-dvh overflow-hidden` clamp that prints one screenful, so the

package/dist/patterns/calendar/calendar.types.d.ts

@@ -371,6 +371,12 @@ export interface CalendarWaitingEntry {
     createdDay: number;
     /** Story-only: the patient's number can receive WhatsApp messages. */
     whatsappCapable?: boolean;
+    /** Host: the number WhatsApp can reach (platform `whatsappPhoneNumber`).
+     *  Set, it IS the WhatsApp number and `whatsappCapable` is not read. */
+    whatsappPhoneNumber?: string;
+    /** The row's photo (its own patient's, or the linked appointment's)
+     *  when the host's `patientById` record carries no `avatarSrc`. */
+    patientAvatarUrl?: string;
 }
 export type CalendarHistoryKind = 'created' | 'moved' | 'resized' | 'status' | 'edited' | 'deleted' | 'confirmedByPatient';
 /** Form fields an edit can touch (the platform's audit vocabulary). */

package/dist/patterns/calendar/index.d.ts

@@ -6,8 +6,8 @@ export type { CalendarAppointmentDetails, CalendarDocumentKind, CalendarAppointm
 export { CalendarSeriesScopeChooser, type CalendarSeriesScopeChooserProps, } from './calendar-series-scope-chooser';
 export { SheetHostProvider, useSheetHost, type SheetHostContext, type SheetId, } from './calendar.host';
 export { CALENDAR_PREFERENCE_KEYS, memoryPreferenceAdapter, resetCalendarPreferences, usePersistedPreference, type CalendarPreferenceAdapter, } from './calendar.preferences';
-export { DEFAULT_DISPLAY, VIEW_OPTIONS, type AvailabilityContext, type BacklogFilter, type BacklogItem, type BacklogType, type CalendarFreeSlot, type CalendarEditorCapabilities, type CalendarRow, type CalendarSeries, type DisplaySettings, type DraftSlot, type EditorDraft, type EditorPrefill, type EditorRecurrence, type FindSlotsSeed, type HistoryInput, type PendingMove, type RailFocus, type RecurrenceFrequency, type SlotPatch, type ViewOption, type ViewOptionId, type WaitingEntryDraft, } from './calendar.model';
-export { DEFAULT_WORKSPACE_DISPLAY, WORKSPACE_VIEWS, type ChairNameDisplay, type DeleteOptions, type EditorDraftExtras, type OperatorNameDisplay, type RecurringScope, type RequiredDocsSignMode, type WorkspaceDisplaySettings, type WorkspaceViewId, } from './calendar-workspace.model';
+export { DEFAULT_DISPLAY, VIEW_OPTIONS, type AvailabilityContext, type BacklogFilter, type BacklogItem, type BacklogType, type CalendarFreeSlot, type CalendarEditorCapabilities, type CalendarRow, type CalendarSeries, type DisplaySettings, type DraftSlot, type EditorDraft, type EditorInitialFocus, type EditorPrefill, type EditorRecurrence, type FindSlotsSeed, type HistoryInput, type PendingMove, type RailFocus, type RecurrenceFrequency, type SlotPatch, type ViewOption, type ViewOptionId, type WaitingEntryDraft, } from './calendar.model';
+export { DEFAULT_WORKSPACE_DISPLAY, WORKSPACE_VIEWS, type CalendarWaitingListState, type ChairNameDisplay, type DeleteOptions, type EditorDraftExtras, type OperatorNameDisplay, type RecurringScope, type RequiredDocsSignMode, type WorkspaceDisplaySettings, type WorkspaceViewId, } from './calendar-workspace.model';
 export type { AssociationColorSources, CalendarAnamnesisAnswer, CalendarAppointmentMeta, CalendarBaseEvent, CalendarBookingContact, CalendarBranch, CalendarBusinessHours, CalendarCare, CalendarCareEntry, CalendarCareLink, CalendarCarePlan, CalendarCarePlanEntry, CalendarClosure, CalendarDayHours, CalendarHistoryEntry, CalendarHistoryField, CalendarHistoryKind, CalendarHoliday, CalendarOperatorFilterGroup, CalendarOperatorGroup, CalendarPatient, CalendarPhoneLabel, CalendarPhoneNumber, CalendarPractice, CalendarPracticeFeatures, CalendarPriceList, CalendarSignChannel, CalendarSignDocument, CalendarTaskDetail, CalendarWaitingEntry, CalendarWeeklyHours, CareDescriptionMode, ColorAssociation, FreeSlotQuery, } from './calendar.types';
 export type { CalendarEvent, CalendarEventStatus, CalendarResource, } from '../../components/calendar';
 export type { AppointmentItem } from '../../components/appointment-card';

package/dist/patterns/calendar/index.js

@@ -1,4 +1,4 @@
-import { C as s, a as r, b as E, c as P, D as S, d as o, S as C, V as t, W as d, e as A, i, m as n, r as D, u as W, f as _, g as c } from "../../_chunks/calendar-workspace-BqKBj26r.js";
+import { C as s, a as r, b as E, c as P, D as S, d as o, S as C, V as t, W as d, e as A, i, m as n, r as D, u as W, f as _, g as c } from "../../_chunks/calendar-workspace-B-fUbm62.js";
 export {
   s as CALENDAR_PREFERENCE_KEYS,
   r as CalendarDataProvider,

package/dist/patterns/marketplace-app-shell/index.js

@@ -1,4 +1,4 @@
-import { C as l, M as o } from "../../_chunks/marketplace-app-shell-BwH6Aruw.js";
+import { C as l, M as o } from "../../_chunks/marketplace-app-shell-d2EtcUbe.js";
 export {
   l as ConnectWithAlfadocs,
   o as MarketplaceAppShell

package/dist/patterns/payment-automation-upsell/index.js

@@ -1,4 +1,4 @@
-import { P as a } from "../../_chunks/payment-automation-upsell-BLTdE2em.js";
+import { P as a } from "../../_chunks/payment-automation-upsell-BKmBXU4i.js";
 export {
   a as PaymentAutomationUpsell
 };

package/dist/patterns/signature-request/index.js

@@ -1,4 +1,4 @@
-import { S as o } from "../../_chunks/signature-request-Dej2g86d.js";
+import { S as o } from "../../_chunks/signature-request-D_j2aQu1.js";
 export {
   o as SignatureRequestModal
 };