@alfadocs/ui-kit 1.12.6 → 1.14.0

package/dist/patterns/anamnesis/index.js

@@ -1,4 +1,4 @@
-import { A as e, a as i, L as r, P as n, S as o, T as t, b as l, c as d, d as g, e as A, f as m, g as c, h as E, i as P, j as f, k as S, l as h, m as u, n as T, o as I, p as N, r as R, q as _, s as C, t as L, u as b } from "../../_chunks/anamnesis-summary-rows-BfhxWPO3.js";
+import { A as e, a as i, L as r, P as n, S as o, T as t, b as l, c as d, d as g, e as A, f as m, g as c, h as E, i as P, j as f, k as S, l as h, m as u, n as T, o as I, p as N, r as R, q as _, s as C, t as L, u as b } from "../../_chunks/anamnesis-summary-rows-CRWO8x8g.js";
 export {
   e as Anamnesis,
   i as AnamnesisConfigEditor,

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

@@ -0,0 +1,62 @@
+import { type CalendarData } from './calendar.data';
+import type { CalendarJourney } from './calendar.journey';
+import { type CalendarPreferenceAdapter } from './calendar.preferences';
+import { type EditorPrefill } from './calendar.model';
+import { type WorkspaceDisplaySettings } from './calendar-workspace.model';
+export declare const WORKSPACE_TOOL: {
+    readonly appointments: "appointments";
+    readonly editor: "appointment-editor";
+    readonly waitingList: "waiting-list";
+    readonly bookings: "online-bookings";
+    readonly findSlots: "find-slots";
+};
+export interface CalendarWorkspaceProps {
+    /** The domain state and its handlers — the host implements them. */
+    journey: CalendarJourney;
+    /** The practice's read model, stable for a page load. */
+    data: CalendarData;
+    locale?: string;
+    /** Host-level cog overrides. */
+    initialDisplay?: Partial<WorkspaceDisplaySettings>;
+    /** The platform's `practice_appointment_edit` right — false turns the
+     *  page read-only (no drag, no create, details without write actions). */
+    permissions?: {
+        editAppointment?: boolean;
+    };
+    /** Deep link `focusAppointmentId`: open on the appointment's day, ring
+     *  and scroll to its card and dock its details. */
+    focusAppointmentId?: string;
+    /** Deep link `createParameters`: arrive in CREATE mode — the banner
+     *  stands and the next free-slot click opens the editor prefilled. */
+    createParameters?: {
+        prefill: EditorPrefill;
+        patientName?: string;
+    };
+    /** Deep link `freeSlotClicked`: jump to the slot and open the editor
+     *  prefilled with it. */
+    freeSlot?: EditorPrefill;
+    /** Platform advisories the finder raises when the scheduler is empty. */
+    businessHours?: {
+        practice?: boolean;
+        operators?: boolean;
+    };
+    /** Where the cog's settings, the view, the weekend choice and the
+     *  chair / operator selections are remembered — the host's per-user
+     *  store. Defaults to the session-scoped in-memory adapter. */
+    preferences?: CalendarPreferenceAdapter;
+    /** The grid's instance id — the agent registry's handle for this
+     *  calendar and the DOM hook anything outside React reaches it by.
+     *  Override it only when two workspaces share one page. */
+    id?: string;
+}
+/**
+ * The cog's settings as the workspace opens with them: the remembered
+ * entry under the workspace's own key, a caller's `initialDisplay`
+ * winning for the keys it names. Exported so a host seeding its journey
+ * (row colours follow `colorAssociation`) starts from the same values
+ * the workspace will show.
+ */
+export declare function initialWorkspaceDisplay(initialDisplay: Partial<WorkspaceDisplaySettings> | undefined, preferences?: CalendarPreferenceAdapter): WorkspaceDisplaySettings;
+/** The workspace root: the read model, then the rail scope, then the page. */
+export declare function CalendarWorkspace({ data, ...props }: CalendarWorkspaceProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=calendar-workspace.d.ts.map

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

@@ -0,0 +1,358 @@
+/**
+ * Calendar demo, Increment 1 — the pure model the rail-hosted surface
+ * adds on top of `calendar.model.ts`: the four-way range view with its
+ * keyboard shortcuts, the extended display settings (default duration,
+ * name display, map link), the practice-hours time axis, the platform's
+ * filter semantics (nothing ticked = everyone) and the split-button
+ * badge count. No React, no i18n lookups. Every read of practice data
+ * goes through the explicit `data: CalendarData` parameter.
+ */
+import type { AppointmentItem } from '../../components/appointment-card';
+import type { CalendarResource } from '../../components/calendar';
+import type { CalendarData } from './calendar.data';
+import type { CalendarPatient, CalendarWaitingEntry } from './calendar.types';
+import { type CalendarRow, type DisplaySettings, type EditorDraft, type EditorPrefill, type WaitingQuickView } from './calendar.model';
+/** The platform's four ranges; "Working week" became the Show-weekends
+ *  item, so it is no longer a view of its own. */
+export type WorkspaceViewId = 'day' | 'threeDays' | 'week' | 'month';
+export declare const WORKSPACE_VIEWS: readonly WorkspaceViewId[];
+/** CalendarView stem per range — composed with the column axis. */
+export declare const WORKSPACE_VIEW_STEM: Record<WorkspaceViewId, 'Day' | 'ThreeDays' | 'Week' | 'Month'>;
+/** Google-Calendar-style single-key shortcuts (X = 3 days, as GCal). */
+export declare const VIEW_SHORTCUT_KEYS: Record<WorkspaceViewId, string>;
+export declare const readWorkspaceViewId: (raw: unknown) => WorkspaceViewId | undefined;
+/** The range a bare key press selects, case-insensitive; undefined when
+ *  the key is not a shortcut. */
+export declare function viewForShortcutKey(key: string): WorkspaceViewId | undefined;
+export declare function shortcutAllowedOn(target: EventTarget | null): boolean;
+/** The keydown shape the shortcut resolver reads — a subset of
+ *  KeyboardEvent so tests can pass plain objects. */
+export interface ShortcutKeydown {
+    key: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+    repeat: boolean;
+    defaultPrevented: boolean;
+    target: EventTarget | null;
+}
+/** The range a page-level keydown switches to, or undefined when the
+ *  press must be left alone (modifier, auto-repeat, typing, an open
+ *  menu or dialog, already handled). */
+export declare function shortcutViewForKeydown(event: ShortcutKeydown): WorkspaceViewId | undefined;
+/** Weekend visibility is a per-user choice now (platform hidden days):
+ *  off hides Saturday and Sunday in every range view. */
+export declare function weekendHiddenDays(showWeekends: boolean): number[];
+export type OperatorNameDisplay = 'full' | 'initials';
+export type ChairNameDisplay = 'full' | 'short';
+export interface WorkspaceDisplaySettings extends DisplaySettings {
+    /** The per-user default appointment length (platform 30). */
+    defaultDurationMin: number;
+    /** Column header treatment for people: dot + name, or initials disc. */
+    operatorNameDisplay: OperatorNameDisplay;
+    /** Column header treatment for chairs: full name or the short code. */
+    chairNameDisplay: ChairNameDisplay;
+    /** Show the Google Maps link in the appointment details. */
+    mapsLink: boolean;
+}
+export declare const DEFAULT_DURATION_RANGE: {
+    readonly min: 5;
+    readonly max: 240;
+    readonly step: 5;
+};
+export declare const DEFAULT_WORKSPACE_DISPLAY: WorkspaceDisplaySettings;
+/** Remembered Increment 1 display settings, validated per field over the
+ *  Increment 1 defaults (a Final State shape keeps every knob it knows). */
+export declare function readWorkspaceDisplaySettings(raw: unknown): WorkspaceDisplaySettings | undefined;
+/** Earliest opening and latest closing across the practice's week —
+ *  the platform's `openingTime` / `closingTime` for the time axis. */
+export declare function practiceDayWindow(data: CalendarData): {
+    min: string;
+    max: string;
+};
+/** The axis for a cog window: `working` is the practice's own hours;
+ *  extended and full stay the Final State overrides. */
+export declare function workspaceDayWindow(window: DisplaySettings['window'], data: CalendarData): {
+    min: string;
+    max: string;
+};
+/** The ids a selection shows: the ticked ones, or all when none is. */
+export declare function effectiveIds(selected: readonly string[], all: readonly string[]): string[];
+/** Tick or untick `ids` in a selection (a row or a whole group). */
+export declare function toggleSelectedIds(prev: readonly string[], ids: readonly string[], checked: boolean | 'indeterminate'): string[];
+/** What the Reset chip counts: every ticked chair and operator. */
+export declare function activeFilterCount(selectedChairIds: readonly string[], selectedOperatorIds: readonly string[]): number;
+/**
+ * Disabled operators holding at least one appointment that STARTS inside
+ * the visible range — the platform's carve-out
+ * (`NewCalendar/Library.js`: `isActive(op) || hasAppointments(op)`).
+ * Their column stands whatever the "Show disabled operators" switch
+ * says, so hiding the operator can never hide an appointment.
+ */
+export declare function bookedDisabledOperatorIds(rows: readonly CalendarRow[], inactiveIds: readonly string[], range: {
+    start: number;
+    end: number;
+} | null): string[];
+/**
+ * The operators the grid may give a column to when NOTHING is ticked:
+ * every active one, the disabled ones while the switch reveals them, and
+ * any disabled operator the carve-out keeps. An explicit selection still
+ * wins over all three (platform: `kept.filter(selected)`).
+ */
+export declare function columnableOperatorIds(args: {
+    operators: readonly CalendarResource[];
+    inactiveIds: readonly string[];
+    showDisabled: boolean;
+    keepIds: readonly string[];
+}): string[];
+/** The operators the filter list offers — disabled ones only once the
+ *  session switch reveals them (the carve-out is a column, not a row). */
+export declare function listedOperators(operators: readonly CalendarResource[], inactiveIds: readonly string[], showDisabled: boolean): CalendarResource[];
+/** Chair column label per the cog: the full name, or the fixture's short
+ *  code (the platform's "first two letters" setting). */
+export declare function chairResourceTitle(chair: CalendarResource, mode: ChairNameDisplay): string;
+/** Operator column label: the plain name, or the name plus the muted
+ *  Disabled marker when the practice has disabled them. The kit Calendar
+ *  renders a resource header from its `title`, so the marker rides
+ *  there — and reaches the Avatar's accessible name under initials. */
+export declare function operatorResourceTitle(operator: CalendarResource, isDisabled: boolean, disabledLabel: string): string;
+/** Whole minutes between two instants — the resize toast's figure. */
+export declare function minutesBetween(start: Date | string, end: Date | string): number;
+/** Re-ends one appointment. The resize path writes through this twice —
+ *  once for the drag, once for the Undo that restores the old end — so
+ *  the two can never drift apart. */
+export declare function rowsWithEnd(rows: readonly CalendarRow[], eventId: string, end: Date): CalendarRow[];
+/** The platform's recurring-mode chooser (move, delete, save on edit). */
+export type RecurringScope = 'this' | 'following' | 'all';
+export declare const RECURRING_SCOPES: readonly RecurringScope[];
+/** Literal map (not a template) so key extractors see every key. */
+export declare const RECURRING_SCOPE_LABEL_KEY: Record<RecurringScope, string>;
+/** How the create form asks for the required documents' signature. */
+export type RequiredDocsSignMode = 'sms' | 'email' | 'none';
+/** What the editor reports beside the draft — the platform-only choices
+ *  the shared `EditorDraft` never needed. */
+export interface EditorDraftExtras {
+    recurringSaveMode?: RecurringScope;
+    requiredDocsSignMode?: RequiredDocsSignMode;
+    branchId?: string;
+}
+/** Delete confirmation choices — the recurring scope and, for a
+ *  price-list recurrence parent, the care-plan cleanup. */
+export interface DeleteOptions {
+    scope: RecurringScope;
+    removeFromCarePlan?: boolean;
+}
+/** The occurrences a scope names, in series order — the event itself
+ *  for `this`, it and its later occurrences for `following`, the whole
+ *  series for `all`. A row outside a series only ever names itself. */
+export declare function seriesScopeEventIds(rows: readonly CalendarRow[], eventId: string, scope: RecurringScope): string[];
+/** Every timed appointment overlapping `[start, end)` — cancelled and
+ *  absent ones, tasks, washes and the row itself never count (platform
+ *  busy check). */
+export declare function slotConflicts(rows: readonly CalendarRow[], slot: {
+    start: Date;
+    end: Date;
+    chairId?: string;
+    operatorId?: string;
+    excludeEventId?: string;
+}): {
+    chairBusy: boolean;
+    operatorBusy: boolean;
+};
+/** Devices the chosen cares need, deduplicated, in care order. */
+export declare function devicesForCares(cares: readonly {
+    careId?: string;
+}[] | undefined, devicesByCare: Readonly<Record<string, readonly string[]>>): string[];
+/** Which sign channels a patient can take a request on. */
+export declare function signChannelsFor(patient: CalendarPatient | undefined): {
+    sms: boolean;
+    email: boolean;
+};
+/** The platform's default: SMS when the patient can take one, else
+ *  email, else nothing. */
+export declare function defaultSignMode(patient: CalendarPatient | undefined): RequiredDocsSignMode;
+/** Google Maps search for the patient's address — the popover's map link. */
+export declare function patientMapsUrl(patient: CalendarPatient): string;
+/** A CREATE mode armed by a deep link (`createParameters`) or the
+ *  Backlog's Schedule: the next empty-slot click opens the editor with
+ *  this context already filled in (platform `_switchMode('create')`). */
+export interface CreateModeRequest {
+    tick: number;
+    prefill: EditorPrefill;
+    /** Named in the banner when the context carries a patient. */
+    patientName?: string;
+}
+/** Legible ink for a mode banner tinted with an appointment colour. The
+ *  Google palette ships no text colour, so the pair is settled by the
+ *  kit's own contrast maths rather than by eye. */
+export declare function bannerTextColor(backgroundHex?: string): string | undefined;
+/** A Move… or Copy… armed from the details dialog: the next empty-slot
+ *  click places the source appointment there. */
+export interface PlacementRequest {
+    kind: 'move' | 'copy';
+    eventId: string;
+    /** Copy only — carry the linked treatments along (platform's two copies). */
+    withTreatments?: boolean;
+    /** Armed from a waiting-list Reschedule — the entry leaves the queue
+     *  once the move lands (platform parity). */
+    waitingEntryId?: string;
+}
+/** The platform's "Copia & incolla": the same appointment on a new slot
+ *  with a fresh id — never a series member, treatments only on request.
+ *  An all-day source stays all-day on the target date. */
+export declare function copyRowAt(source: CalendarRow, target: {
+    start: Date;
+    resourceId?: string;
+    axisKind: DisplaySettings['resourceKind'];
+}, id: string, withTreatments: boolean): CalendarRow;
+/** Apply an edit saved with "this and following" / "all" to the other
+ *  occurrences: each keeps its own day shifted by the same delta as the
+ *  edited one, and takes the edited duration, allocation, colour, status,
+ *  type and description. */
+export declare function applySeriesEdit(rows: readonly CalendarRow[], primaryPrev: CalendarRow, draft: EditorDraft, siblingIds: readonly string[], data: CalendarData): CalendarRow[];
+/** What the post-save toast needs to decide whether the saved
+ *  appointment is on screen: its day and its allocation. */
+export interface SaveNotice {
+    tick: number;
+    date: Date;
+    chairId?: string;
+    operatorId?: string;
+}
+/** Why a saved appointment is not on the grid right now — empty when it
+ *  is visible. The "Go to" action undoes exactly these. */
+export declare function hiddenReasons(notice: Pick<SaveNotice, 'date' | 'chairId' | 'operatorId'>, view: {
+    visibleRange: {
+        start: number;
+        end: number;
+    } | null;
+    hiddenDays: readonly number[];
+    selectedChairIds: readonly string[];
+    selectedOperatorIds: readonly string[];
+}): Array<'range' | 'weekend' | 'chair' | 'operator'>;
+/**
+ * The platform DASHBOARD widget's window (`upcomingAppointmentsAction`):
+ * NOW → `forwardDays` later at 23:59:59.999, cancelled excluded, date
+ * ascending, no row limit. `backDays` is 0 at rest — the kit timeline's
+ * presets and its edge loaders widen the derived window in place of a
+ * fetch, so the panel can look further than the platform's seven days.
+ */
+export interface UpcomingWindow {
+    /** Days of history the panel has been widened to; 0 starts at NOW. */
+    backDays: number;
+    /** Days ahead — the platform's seven at rest. */
+    forwardDays: number;
+}
+/** Platform default: now to the end of the seventh day. */
+export declare const UPCOMING_FORWARD_DAYS = 7;
+/** How far one widening step reaches at either edge. */
+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. */
+export declare function upcomingWindowBounds(nowIso: string, window: UpcomingWindow): {
+    startMs: number;
+    endMs: number;
+};
+/** One widening step at either edge, capped at the ceiling. */
+export declare function widenUpcomingWindow(window: UpcomingWindow, edge: 'earlier' | 'later'): UpcomingWindow;
+/** Widen just far enough to reach `targetIso` — the timeline's presets and
+ *  its jump-to-date land on days the default seven never covered. */
+export declare function upcomingWindowCovering(window: UpcomingWindow, nowIso: string, targetIso: string): UpcomingWindow;
+/**
+ * The rows the widget lists: appointments starting inside the window,
+ * cancelled excluded, date ascending. Background washes and the composing
+ * draft never qualify; tasks are already out of the Increment 1 feed.
+ */
+export declare function upcomingAppointmentRows(rows: CalendarRow[], bounds: {
+    startMs: number;
+    endMs: number;
+}): CalendarRow[];
+/** One agenda row as the kit timeline's item — identity, allocation and
+ *  care lines; the row id stays the event id so a click maps straight
+ *  back onto the grid. */
+export declare function upcomingAppointmentItem(row: CalendarRow, privacy: boolean, data: CalendarData): AppointmentItem;
+/** How far back the platform's booking query looks, on `createdAt`. */
+export declare const ONLINE_BOOKINGS_WINDOW_DAYS = 30;
+/**
+ * Bookings still to check: created online (or through the API) within
+ * the last 30 days, not cancelled, and still missing a patient OR an
+ * operator. Mirrors the repository query behind the platform's alert
+ * strip; Increment 1 renders the same count on a toolbar button.
+ */
+export declare function onlineBookingsToCheck(rows: readonly CalendarRow[], data: CalendarData): CalendarRow[];
+/**
+ * One row of the platform's "Prenotazioni online" page, which Increment 1
+ * hosts in the rail instead of sending the user to a separate page.
+ * Columns mirror it: when it was booked, what was asked for, whether it
+ * was paid online, and what is still missing before it is a real
+ * appointment.
+ */
+export interface BookingRowView {
+    row: CalendarRow;
+    eventId: string;
+    /** The appointment's own start. */
+    start: Date;
+    /** Platform `createdAt` — "del <date>" under the appointment date. */
+    bookedAt: Date | null;
+    /** The booking reason, or the platform's "Non specificato". */
+    reason: string | null;
+    chairTitle: string | null;
+    /** Stripe amount when the patient paid at booking. */
+    paidOnline: number | null;
+    needsPatient: boolean;
+    needsOperator: boolean;
+    /** Booked after the user last opened the page — the "(Nuovo)" marker. */
+    isNew: boolean;
+}
+/** Bookings made after this instant carry the platform's "(Nuovo)" tag. */
+export declare const DEFAULT_BOOKINGS_LAST_SEEN_ISO = "2026-06-23T00:00:00";
+export declare function bookingRowView(row: CalendarRow, data: CalendarData, lastSeenMs?: number): BookingRowView;
+/** The nine advanced inputs, all optional. Empty = the input is unset;
+ *  `operatorId` also accepts `NONE`, the platform's "no operator". */
+export interface WaitingListFilters {
+    patientId: string;
+    patientAssigned: '' | 'yes' | 'no';
+    operatorId: string;
+    appointmentScheduled: '' | 'yes' | 'no';
+    appointmentFrom?: Date;
+    appointmentTo?: Date;
+    waitingFrom?: Date;
+    waitingTo?: Date;
+    description: string;
+}
+export declare const EMPTY_WAITING_FILTERS: WaitingListFilters;
+/** How many of the nine inputs carry a value — the toggle's badge. */
+export declare function waitingFiltersActiveCount(filters: WaitingListFilters): number;
+/**
+ * One waiting row resolved the way the platform's serializer resolves
+ * it: the entry's OWN patient, the linked appointment with its patient,
+ * care line and colour, and the operator default. `noConnection` is the
+ * platform's "Nessun collegamento" test — none of the four is present.
+ */
+export interface WaitingListRowView {
+    entry: CalendarWaitingEntry;
+    /** Platform `patientId` / `patientName` / `patientPhoneNumber`. */
+    patient?: CalendarPatient;
+    /** The linked appointment, live from the grid's rows. */
+    appointment?: CalendarRow;
+    /** Platform `appointmentPatientId` — the linked appointment's patient. */
+    appointmentPatient?: CalendarPatient;
+    /** Platform `operatorName`. */
+    operatorTitle?: string;
+    /** Platform `appointmentName` — the linked appointment's care line. */
+    appointmentName?: string;
+    noConnection: boolean;
+}
+export declare function waitingListRowView(entry: CalendarWaitingEntry, rows: readonly CalendarRow[], data: CalendarData): WaitingListRowView;
+/**
+ * The platform's advanced predicates, in its own order. A patient
+ * matches the entry's OWN patient or the linked appointment's; the
+ * operator and the description only ever read the ENTRY's own fields.
+ */
+export declare function waitingEntryMatchesFilters(view: WaitingListRowView, filters: WaitingListFilters, data: CalendarData): boolean;
+/** 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[];
+//# sourceMappingURL=calendar-workspace.model.d.ts.map

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

@@ -0,0 +1,122 @@
+/**
+ * Calendar pattern — the READ MODEL the host supplies, stable for a page
+ * load: the practice's resources, catalogue, agenda extras and lookups.
+ * It mirrors what the demo once read straight from its fixture module —
+ * one property per constant, one method per fixture-backed helper — so
+ * the demos hand in their fixtures and the platform island hands in what
+ * `/internalApi/...` returned, and the model, panels and surface compute
+ * from either without knowing which.
+ *
+ * Provided once with `<CalendarDataProvider value={data}>`; components
+ * read it with `useCalendarData()`, pure model functions take it as an
+ * explicit `data` parameter — never a module-level global.
+ *
+ * Every REQUIRED member is one the shipped runtime actually reads. The
+ * handful marked optional are read only by the story-only Final State
+ * demo (`src/patterns/demos/calendar/`), which keeps supplying them; a
+ * platform host mounting `CalendarWorkspace` can leave them out.
+ */
+import { type ReactNode } from 'react';
+import type { CalendarResource } from '../../components/calendar';
+import type { AppointmentItem } from '../../components/appointment-card';
+import type { NotesPanelNote } from '../../components/notes-panel';
+import type { TasksPanelItem } from '../../components/tasks-panel';
+import type { CalendarAppointmentMeta, CalendarBaseEvent, CalendarBookingContact, CalendarBranch, CalendarBusinessHours, CalendarCare, CalendarCareEntry, CalendarCareLink, CalendarCarePlan, CalendarClosure, CalendarHistoryEntry, CalendarHoliday, CalendarOperatorGroup, CalendarPatient, CalendarPracticeFeatures, CalendarPriceList, CalendarTaskDetail, CalendarWaitingEntry } from './calendar.types';
+export interface CalendarData {
+    chairs: readonly CalendarResource[];
+    operators: readonly CalendarResource[];
+    /** Operator groups (platform `OperatorGroup`) for the grouped filter. */
+    operatorGroups: readonly CalendarOperatorGroup[];
+    /** Operators the practice has disabled (platform `isActive === false`). */
+    inactiveOperatorIds: readonly string[];
+    /** Operator id → local ISO dates the operator is away. */
+    operatorAbsences: Record<string, readonly string[]>;
+    /** Operator id → absence display title (a sibling map, optional per operator). */
+    operatorAbsenceTitles: Record<string, string>;
+    holidays: readonly CalendarHoliday[];
+    /** Practice-closed local ISO dates. */
+    closedDates: readonly string[];
+    /** JS `getDay()` numbers the practice does not work. Optional: the
+     *  shipped workspace derives its hidden days from `businessHours` and
+     *  the weekend toggle; only the Final State demo reads this. */
+    nonWorkingDays?: readonly number[];
+    businessHours: CalendarBusinessHours;
+    /** The clock every relative label and ledger stamp is pinned to. */
+    nowIso: string;
+    /** The date the calendar opens on. */
+    initialDateIso: string;
+    cares: readonly CalendarCare[];
+    priceLists: readonly CalendarPriceList[];
+    /** Optional: no shipped code reads the flat list — the panels go
+     *  through `carePlanById` / `openCarePlansForPatient`. */
+    carePlans?: readonly CalendarCarePlan[];
+    patients: readonly CalendarPatient[];
+    /** The appointments and tasks as the host loaded them, no resource axis. */
+    baseEvents: readonly CalendarBaseEvent[];
+    /** Event id → appointment extras (patient, operator, chair, care, billing). */
+    metaById: Record<string, CalendarAppointmentMeta>;
+    /** Event id → the note the patient left on the online booking form. */
+    bookingNotes: Record<string, string>;
+    /** Event id → what the person typed on the booking website. */
+    bookingContacts: Record<string, CalendarBookingContact>;
+    /** Task-event id → its chair / operator axis (tasks carry no meta).
+     *  Optional: the shipped workspace drops tasks at the feed boundary;
+     *  only the Final State demo, which shows them, reads this. */
+    taskAxis?: Record<string, {
+        chairId: string;
+        operatorId: string;
+    }>;
+    /** Event id → platform-shaped task detail. */
+    taskDetails: Record<string, CalendarTaskDetail>;
+    /** The waiting list as loaded — the journey seeds its state from it. */
+    waitingList: readonly CalendarWaitingEntry[];
+    /** Event id → the modification ledger as loaded. Optional: the
+     *  workspace reads the ledger off `CalendarJourney.history`, which the
+     *  host seeds however it likes. */
+    appointmentHistory?: Record<string, CalendarHistoryEntry[]>;
+    practiceFeatures: CalendarPracticeFeatures;
+    branches: readonly CalendarBranch[];
+    /** Care id → the medical devices it needs. */
+    careDevices: Readonly<Record<string, readonly string[]>>;
+    /** Patient id → required documents still unsigned. */
+    unsignedRequiredDocs: Readonly<Record<string, number>>;
+    /** Patients with an advanced e-signature (AES) setup. */
+    patientsWithAes: ReadonlySet<string>;
+    /** Appointment id → the deposit paid online when booking. */
+    paidOnline: Readonly<Record<string, number>>;
+    /** Appointment id → the phone typed on the booking site. */
+    bookingPhones: Readonly<Record<string, string>>;
+    patientById(id: string): CalendarPatient | undefined;
+    patientNotes(patientId: string): NotesPanelNote[];
+    patientAppointments(patientId: string): AppointmentItem[];
+    patientTasks(patientId: string): TasksPanelItem[];
+    careById(id: string): CalendarCare | undefined;
+    carePlanById(id: string): CalendarCarePlan | undefined;
+    /** Optional: no shipped code calls it — the editor links through
+     *  `openCarePlansForPatient`, the details panel through
+     *  `carePlanById`. */
+    carePlansForPatient?(patientId: string): CalendarCarePlan[];
+    /** Plans the editor may link to: not discarded or closed, with undone lines. */
+    openCarePlansForPatient(patientId: string): CalendarCarePlan[];
+    /** The care entries a link resolves to — plan lines in plan order, or
+     *  the price-list picks. Unknown ids are dropped. */
+    careEntriesFromLink(link: CalendarCareLink): CalendarCareEntry[];
+    /** Closed dates plus holidays, unless the practice stays open on them. */
+    practiceClosedOn(dateIso: string): boolean;
+    /** Why a date (or, given an operator, that column) cannot take a
+     *  booking — closed > holiday > absence; null when it can. */
+    closureOn(dateIso: string, operatorId?: string): CalendarClosure | null;
+    /** Local dates in [from, to] with practice hours that are neither
+     *  closed nor a holiday. */
+    openDatesBetween(from: Date, to: Date): string[];
+    /** Waiting-since instant for an entry (platform `createdAt`). */
+    waitingSinceIso(entry: CalendarWaitingEntry): string;
+}
+/** Wrap whatever renders the calendar's panels and surface — one provider
+ *  per subtree is fine (a rail renders its panels outside the page tree). */
+export declare function CalendarDataProvider({ value, children, }: {
+    value: CalendarData;
+    children?: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<CalendarData | null>>;
+export declare function useCalendarData(): CalendarData;
+//# sourceMappingURL=calendar.data.d.ts.map

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

@@ -0,0 +1,10 @@
+export type SheetId = 'appointment-editor' | 'appointment-details' | 'find-slots' | 'backlog' | 'patient-care-plan';
+export interface SheetHostContext {
+    open(id: SheetId): void;
+    close(): void;
+}
+/** Wrap whatever renders the panels and the surface — one provider per
+ *  subtree is fine (a rail renders its panels outside the page tree). */
+export declare const SheetHostProvider: import("react").Provider<SheetHostContext | null>;
+export declare function useSheetHost(): SheetHostContext;
+//# sourceMappingURL=calendar.host.d.ts.map