@alfadocs/ui-kit-debug 1.13.0 → 1.14.0

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

@@ -0,0 +1,684 @@
+/**
+ * Calendar demo — the pure model: row and display types, the editor's
+ * prefill / draft shapes, recurrence, the history ledger, the Backlog
+ * queue, closures and availability shading, the print-sheet builder and
+ * the free-slot search. No React, no i18n lookups (`closureReason`
+ * takes the caller's `t`). Shared by the Final State (rail) demo and the
+ * Increment 1 workspace, so both compute from one source. Every read of
+ * practice data goes through the explicit `data: CalendarData` parameter
+ * — the host supplies it, the model never reaches for a module global.
+ */
+import type { TFunction } from 'i18next';
+import { ThumbsUp } from 'lucide-react';
+import { type CalendarEvent, type CalendarEventStatus, type CalendarResource } from '../../components/calendar';
+import type { CalendarData } from './calendar.data';
+import { type CareDescriptionMode, type ColorAssociation, type CalendarBaseEvent, type CalendarBookingContact, type CalendarCareEntry, type CalendarCareLink, type CalendarClosure, type CalendarDayHours, type CalendarHistoryEntry, type CalendarPatient, type CalendarPhoneNumber, type CalendarSignDocument, type CalendarWaitingEntry } from './calendar.types';
+export declare const STATUS_UI_KEY: Record<CalendarEventStatus, string>;
+export interface CalendarRow {
+    event: CalendarEvent;
+    chairId?: string;
+    operatorId?: string;
+    /** Set on every occurrence of a repeating series. */
+    series?: CalendarSeries;
+    /** Care entries — the card's care line derives from these per cog mode. */
+    cares?: CalendarCareEntry[];
+    /** Free-text description (platform `name`); fixtures carry none. */
+    description?: string;
+    /** Where the cares came from — a care plan's lines or a price list. */
+    careLink?: CalendarCareLink;
+}
+/**
+ * A drag/resize of a PATIENT appointment awaiting confirmation (ported
+ * from the 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.
+ */
+export interface PendingMove {
+    event: CalendarEvent;
+    kind: 'drop' | 'resize';
+    oldStart: Date;
+    newStart: Date;
+    oldEnd?: Date;
+    /** Post-drop end, snapshotted so a re-commit cannot re-apply the delta. */
+    newEnd?: Date;
+    /** Post-drop column. `event.resourceId` still reports the OLD one. */
+    newResourceId?: string;
+    revert?: () => void;
+}
+export declare function movesSilently(event: CalendarEvent): boolean;
+export declare function isPendingBooking(event: CalendarEvent): boolean;
+export declare function selectPendingBookings(rows: CalendarRow[]): CalendarRow[];
+/**
+ * What a grid click focused in the rail. A FRESH object per click (not a
+ * bare id) so re-clicking the same event re-docks its panel after the user
+ * collapsed the rail — the registrar's effect keys on the object identity.
+ */
+export type RailFocus = {
+    kind: 'appointment';
+    eventId: string;
+} | {
+    kind: 'task';
+    eventId: string;
+} | null;
+/**
+ * The RANGE views of the standard calendar experience — a dedicated
+ * segmented split button in the header (Day · 3 days · Working week ·
+ * Week · Month). The chair/operator axis and the columns/timeline
+ * orientation are NOT views: they are per-user display settings and live
+ * in the cog. Month has no resource variant (platform parity) — it is
+ * always the plain calendar.
+ */
+export type ViewOptionId = 'day' | 'threeDays' | 'workingWeek' | 'week' | 'month';
+export interface ViewOption {
+    id: ViewOptionId;
+    /** CalendarView stem — composed with the cog's group-by axis. */
+    stem: 'Day' | 'ThreeDays' | 'Week' | 'Month';
+    /** Working week trims the weekend regardless of the Sundays setting. */
+    workingWeek?: boolean;
+}
+export declare const VIEW_OPTIONS: ViewOption[];
+/**
+ * On-the-fly DISPLAY settings — the platform buries these per-user knobs in
+ * Settings; the sketch surfaces them in a header cog so users adjust the
+ * view without leaving the agenda. The view knobs are display-only and
+ * instantly reversible. The cog also carries the two per-user data-entry
+ * defaults (care description, colour association): they govern what NEW or
+ * MOVED appointments get, never what is already painted. Default duration
+ * and the business hours themselves stay in Settings.
+ */
+export interface DisplaySettings {
+    /** Which resource axis the columns/rows group by. */
+    resourceKind: 'chair' | 'operator' | 'none';
+    /** Vertical resource columns vs the horizontal timeline. */
+    orientation: 'vertical' | 'horizontal';
+    zebraRows: boolean;
+    showTime: boolean;
+    slotDuration: '00:15' | '00:30' | '01:00';
+    window: 'working' | 'extended' | 'full';
+    /** How the card describes its cares (platform care visualization). */
+    careDescription: CareDescriptionMode;
+    /** Which colour a new or moved appointment inherits. */
+    colorAssociation: ColorAssociation;
+}
+export declare const DEFAULT_DISPLAY: DisplaySettings;
+/** A remembered range view, only while the segment still exists. */
+export declare function readViewOptionId(raw: unknown): ViewOptionId | undefined;
+export declare const DISPLAY_READERS: {
+    [K in keyof DisplaySettings]: (raw: unknown) => DisplaySettings[K] | undefined;
+};
+export declare function readDisplayField<K extends keyof DisplaySettings>(target: DisplaySettings, field: K, raw: unknown): void;
+/**
+ * Remembered display settings, validated PER FIELD over the defaults —
+ * a stale shape from an earlier session keeps every knob it still knows
+ * and never wipes the newer ones. Anything but an object is rejected.
+ */
+export declare function readDisplaySettings(raw: unknown): DisplaySettings | undefined;
+/** Remembered chair / operator selections, kept to the practice's ids. */
+export declare function readChairIds(data: CalendarData): (raw: unknown) => string[] | undefined;
+export declare function readOperatorIds(data: CalendarData): (raw: unknown) => string[] | undefined;
+/** Tri-state for a select-all row over `ids`. */
+export declare function selectionState(selected: readonly string[], ids: readonly string[]): boolean | 'indeterminate';
+/** Time-only Intl options for the peek's semantic `<time>` pair. */
+export declare const PEEK_TIME_FORMAT: Intl.DateTimeFormatOptions;
+export declare const DAY_WINDOWS: Record<DisplaySettings['window'], {
+    min: string;
+    max: string;
+}>;
+export declare function formatTimeRange(locale: string, start: Date | string, end?: Date | string): string;
+export declare function formatDay(locale: string, value: Date | string): string;
+/** Completed years between a birth date and the practice's fixed "now" —
+ *  the platform popover's "(NN anni)" beside the patient's name. Pinned
+ *  to `data.nowIso` so the figure never drifts under a test. */
+export declare function patientAgeYears(dobIso: string, data: CalendarData): number;
+export interface EditorPrefill {
+    /** Set = the editor EDITS this existing event; unset = create. */
+    editEventId?: string;
+    patientId?: string;
+    isTelehealth?: boolean;
+    date?: Date;
+    time?: {
+        hours: number;
+        minutes: number;
+    };
+    durationMin?: number;
+    operatorId?: string;
+    chairId?: string;
+    colorHex?: string;
+    care?: string;
+    /** Care entries riding along (an edit, or a find-free-slots hand-off). */
+    cares?: CalendarCareEntry[];
+    /** The plan lines or price-list picks the cares came from. */
+    careLink?: CalendarCareLink;
+    allDay?: boolean;
+    status?: CalendarEventStatus;
+    /** Online-booking triage: what the person typed on the booking site
+     *  (no patient record yet). Drives the booker block + the platform's
+     *  "search for this patient below" call to action. */
+    bookingContact?: CalendarBookingContact;
+    /** The waiting-list entry this save settles — it leaves the queue when
+     *  the save lands (Schedule creates, Bring forward moves). */
+    waitingEntryId?: string;
+    /** Backlog hand-off: what this edit must settle — a booking needs a
+     *  patient AND an operator; an operator-less appointment needs one. */
+    callToAction?: 'processBooking' | 'assignOperator';
+    /** The platform's `simpleSave`. `false` — a deep-link arrival that has
+     *  somewhere to go back to — splits Save into "save and go back" and
+     *  "save and continue"; anything else keeps the one Save. */
+    simpleSave?: boolean;
+}
+/** Platform's six `recurrence_frequency` values, in its dropdown order. */
+export type RecurrenceFrequency = 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'semiannual' | 'yearly';
+/** Repetition cap — platform asserts 2..100 on the entity. */
+export declare const RECURRENCE_MAX_COUNT = 100;
+/** Dropdown order, matching the platform modal's own. */
+export declare const RECURRENCE_FREQUENCIES: readonly RecurrenceFrequency[];
+/** Literal map (not a template) so key extractors see every key. */
+export declare const RECURRENCE_LABEL_KEY: Record<RecurrenceFrequency, string>;
+export interface EditorRecurrence {
+    frequency: RecurrenceFrequency;
+    /** Count XOR until — the exclusivity `DoctorAppointment` enforces. */
+    ends: 'count' | 'until';
+    /** Occurrences INCLUDING the first, when `ends === 'count'`. */
+    count: number;
+    /** Last date an occurrence may land on, when `ends === 'until'`. */
+    untilDate?: Date;
+    /** Beyond platform: drop occurrences the practice could not honour. */
+    skipClosedDays: boolean;
+}
+/** Step per frequency. Platform's RRULE factory has no QUARTERLY or
+ *  SEMIANNUAL freq either — it rewrites both to MONTHLY with INTERVAL
+ *  3 / 6, which is the same arithmetic. */
+export declare const RECURRENCE_STEP: Record<RecurrenceFrequency, {
+    days?: number;
+    months?: number;
+}>;
+/** Month arithmetic that never rolls over: 31 Jan + 1 month is 28/29
+ *  Feb, not 2/3 March (what a naive `setMonth` would give). */
+export declare function addMonthsClamped(base: Date, months: number): Date;
+/**
+ * A day this appointment cannot be honoured: the practice is shut (no
+ * business hours for that weekday) or the chosen operator is away.
+ * Chair-only bookings check the practice alone.
+ */
+export declare function isUnbookableDay(date: Date, operatorId: string | undefined, data: CalendarData): boolean;
+/**
+ * Expand a rule into the dates that actually get booked. Skipped
+ * candidates do NOT consume the count — asking for 4 appointments
+ * yields 4 appointments, with the closed days stepped over rather than
+ * silently swallowing an occurrence.
+ */
+export declare function expandRecurrence(start: Date, rule: EditorRecurrence, operatorId: string | undefined, data: CalendarData): {
+    dates: Date[];
+    skipped: number;
+};
+/** What an occurrence knows about the series it belongs to — drives the
+ *  details panel's read-only summary (platform disables the recurrence
+ *  inputs once an appointment exists, so this is the only place the
+ *  rule surfaces after saving). */
+export interface CalendarSeries {
+    id: string;
+    frequency: RecurrenceFrequency;
+    /** 1-based position of this occurrence. */
+    index: number;
+    total: number;
+    lastIso: string;
+    /** Candidates dropped as closed/absent days. */
+    skipped: number;
+}
+export interface EditorDraft {
+    editEventId?: string;
+    patientId?: string;
+    isTelehealth: boolean;
+    date: Date;
+    time: {
+        hours: number;
+        minutes: number;
+    };
+    durationMin: number;
+    operatorId?: string;
+    chairId?: string;
+    colorHex: string;
+    care?: string;
+    cares?: CalendarCareEntry[];
+    careLink?: CalendarCareLink;
+    /** The waiting-list entry this save settles (removed from the queue). */
+    waitingEntryId?: string;
+    allDay?: boolean;
+    /** Platform "Lista d'attesa" checkbox — also queue the patient. */
+    addToWaitingList?: boolean;
+    /** Edit mode only — the platform changes status from the popover, but
+        the rail's details-as-form surface owns it here. */
+    status?: CalendarEventStatus;
+    /** Create only, matching platform (its recurrence inputs go disabled
+        the moment an appointment id exists). */
+    recurrence?: EditorRecurrence;
+}
+/** Full-edit prefill for an existing grid event. */
+export declare function editPrefillFromRow(row: CalendarRow): EditorPrefill;
+/**
+ * The slot an open editor is composing, mirrored on the grid as a draft
+ * placeholder so the user can see WHICH timeslot they picked. Carries
+ * `editEventId` when editing an existing appointment — the mirror is
+ * suppressed there, since the real card is already on the grid.
+ */
+export interface DraftSlot {
+    editEventId?: string;
+    date: Date;
+    time: {
+        hours: number;
+        minutes: number;
+    };
+    durationMin: number;
+    allDay: boolean;
+    chairId?: string;
+    operatorId?: string;
+}
+/**
+ * A slot edit made ON THE GRID (dragging or resizing the draft mirror),
+ * pushed back into the open editor. Applied by `tick` so it patches only
+ * the slot fields — the patient, care, colour and the rest of the form
+ * survive untouched.
+ */
+export interface SlotPatch {
+    tick: number;
+    date?: Date;
+    time?: {
+        hours: number;
+        minutes: number;
+    };
+    durationMin?: number;
+    chairId?: string;
+    operatorId?: string;
+}
+export declare const DRAFT_SNAP = "00:15";
+export declare const NONE = "none";
+export declare const DURATION_PRESETS_MIN: number[];
+export declare function durationDigitsFilter(candidate: string, search: string): number;
+/**
+ * The editor's opening colour (platform `_setStateColorId` on mount): an
+ * existing appointment keeps its stored colour; a new one under operator or
+ * chair association adopts the preselected resource's colour, under care
+ * association the hand-off's colour, else the first catalogued care's.
+ */
+export declare function initialEditorColor(prefill: EditorPrefill | undefined, association: ColorAssociation, data: CalendarData): string;
+/** A plan line's booked appointments — entry id → [{ eventId, startIso }]
+ *  in start order (the checklist's "scheduled" chips, the rail's links). */
+export declare function scheduleByEntryId(rows: ReadonlyArray<{
+    event: {
+        id: string;
+        start: string | Date;
+    };
+    careLink?: CalendarCareLink;
+}>): Record<string, Array<{
+    eventId: string;
+    startIso: string;
+}>>;
+/** What a link implies for the form (platform `_getAppointmentDuration`,
+ *  `_getColorIdFromCarePlanEntry` / `_getColorIdFromPriceList`): the
+ *  summed duration, the FIRST line's care colour in plan order, a label. */
+export declare function deriveCareLinkDefaults(link: CalendarCareLink | undefined, data: CalendarData): {
+    durationMin?: number;
+    colorHex?: string;
+    description?: string;
+};
+/** `Omit` that keeps a union's variants apart (plain Omit collapses it). */
+export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/** A ledger line before the journey stamps id, time and actor onto it. */
+export type HistoryInput = DistributiveOmit<CalendarHistoryEntry, 'id' | 'atIso' | 'actor'>;
+/** Absolute stamp for booked-at and ledger lines — day and time. */
+export declare const DETAIL_STAMP_FORMAT: Intl.DateTimeFormatOptions;
+/** Live stamps advance from the practice clock, never the real one. */
+export declare function historyStampIso(seq: number, data: CalendarData): string;
+/** Timeline 'newest-first' is a plain column — DOM order must already be. */
+export declare function sortHistoryNewestFirst(entries: readonly CalendarHistoryEntry[]): CalendarHistoryEntry[];
+/** Documents still awaiting a required party (the chip's own rule). */
+export declare function signingSummary(docs: readonly CalendarSignDocument[]): {
+    toSign: number;
+    allSigned: boolean;
+};
+/**
+ * What a Save changed, as ledger lines: a status change, a move (start
+ * differs), a resize (other duration) and one `edited` line naming the
+ * other fields that differ. Empty when nothing changed.
+ */
+export declare function historyEntriesFromEdit(prev: CalendarRow, draft: EditorDraft, data: CalendarData): HistoryInput[];
+/** One "From price list" row: a care pick and its (editable) price. */
+export interface PriceRow {
+    key: number;
+    careId: string;
+    priceCents: number | null;
+    /** Booked subset of the care's catalogue phases (platform per-row
+     *  phase checkboxes); empty when the care has none. */
+    phases?: string[];
+    /** Already invoiced — the whole row is read-only (platform "Azione
+     *  non consentita: Prestazione già fatturata"). */
+    billed?: boolean;
+}
+export declare const EMPTY_SCHEDULE: Record<string, Array<{
+    eventId: string;
+    startIso: string;
+}>>;
+/** The patient's price list by name, else the practice default. */
+export declare function priceListIdFor(patientId: string | undefined, data: CalendarData): string;
+export declare const STATUS_CHIP: Record<CalendarEventStatus, {
+    variant: 'success' | 'info' | 'warning' | 'error' | 'accentSoft';
+    Icon: typeof ThumbsUp;
+}>;
+export type BacklogType = 'booking' | 'waiting' | 'unconfirmed' | 'noOperator' | 'signature';
+/** The filter strip's segments — every type, or all of them grouped. */
+export type BacklogFilter = BacklogType | 'all';
+/** Group order in the All view (and the strip's segment order). */
+export declare const BACKLOG_TYPES: readonly BacklogType[];
+/** One row of the queue. `startIso` sorts each group in day order. */
+export type BacklogItem = {
+    type: 'booking';
+    id: string;
+    startIso: string;
+    row: CalendarRow;
+} | {
+    type: 'waiting';
+    id: string;
+    startIso: string;
+    entry: CalendarWaitingEntry;
+} | {
+    type: 'unconfirmed';
+    id: string;
+    startIso: string;
+    row: CalendarRow;
+} | {
+    type: 'noOperator';
+    id: string;
+    startIso: string;
+    row: CalendarRow;
+} | {
+    type: 'signature';
+    id: string;
+    startIso: string;
+    row: CalendarRow;
+    toSign: number;
+};
+/** A concluded appointment has nobody left to assign. */
+export declare const SETTLED_STATUSES: ReadonlySet<CalendarEventStatus>;
+/** Epoch ms of an event start — date-only starts are LOCAL midnight. */
+export declare function eventStartMs(iso: string): number;
+/** What the waiting-list entry is about, if a loaded appointment. */
+export declare function waitingEntryAppointment(entry: CalendarWaitingEntry, data: CalendarData): CalendarBaseEvent | undefined;
+/**
+ * Derive the whole queue from live state. Bookings, operator-less
+ * appointments and pending signatures span the fixture week; unconfirmed
+ * appointments are scoped to the grid's visible range (the week would
+ * list every not-yet-confirmed filler row). Groups sort by day.
+ */
+export declare function buildBacklog(args: {
+    rows: CalendarRow[];
+    waitingList: CalendarWaitingEntry[];
+    visibleRange: {
+        start: number;
+        end: number;
+    } | null;
+}, data: CalendarData): BacklogItem[];
+/** Per-type counts — the strip's segment badges. */
+export declare function backlogCounts(items: readonly BacklogItem[]): Record<BacklogType, number>;
+/** The patient behind a row (bookings have none — a typed name only). */
+export declare function backlogPatient(item: BacklogItem, data: CalendarData): CalendarPatient | undefined;
+/** The row's headline — patient name, the booker's typed name, or the
+ *  free-text hold. */
+export declare function backlogName(item: BacklogItem, data: CalendarData): string | undefined;
+/**
+ * Text search over what the ROW renders: the patient's name (own, or the
+ * linked appointment's) and the description (own, or the linked
+ * appointment's care). Case-insensitive substring; empty matches all.
+ */
+export declare function waitingEntryMatches(entry: CalendarWaitingEntry, query: string, data: CalendarData): boolean;
+/** Text search over a row: name, care line, note and operator. */
+export declare function backlogItemMatches(item: BacklogItem, query: string, data: CalendarData): boolean;
+/** The strip segment plus the text search, in one pass. */
+export declare function filterBacklog(items: readonly BacklogItem[], filter: BacklogFilter, query: string, data: CalendarData): BacklogItem[];
+export type WaitingQuickView = 'all' | 'noAppointment' | 'scheduledOver30' | 'waitingOver30';
+export declare const WAITING_QUICK_VIEWS: readonly WaitingQuickView[];
+/** Literal map (not a template) so key extractors see every key. */
+export declare const WAITING_QUICK_VIEW_LABEL_KEY: Record<WaitingQuickView, string>;
+/** The platform's threshold for both "over 30 days" quick views. */
+export declare const WAITING_QUICK_VIEW_DAYS = 30;
+/** Whether an entry passes a quick view, measured from the practice clock. */
+export declare function waitingEntryInQuickView(entry: CalendarWaitingEntry, view: WaitingQuickView, data: CalendarData): boolean;
+/** Apply a quick view to a queue — every non-waiting row passes through
+ *  untouched (the platform's dropdown only ever saw waiting entries). */
+export declare function filterWaitingQuickView(items: readonly BacklogItem[], view: WaitingQuickView, data: CalendarData): BacklogItem[];
+/**
+ * Process an online booking: the editor opens for THAT event with the
+ * booker's typed details, a matching record pre-selected, and BOTH the
+ * patient and the operator marked required — the two things the booking
+ * needs before it leaves the queue.
+ */
+export declare function processBookingPrefill(row: CalendarRow, data: CalendarData): EditorPrefill;
+/** Assign an operator: the editor opens for the event with the operator
+ *  select as the call to action. */
+export declare function assignOperatorPrefill(row: CalendarRow): EditorPrefill;
+/**
+ * Whether the editor's Backlog call to action is settled: processing a
+ * booking needs the patient record AND the operator, assigning needs the
+ * operator; with no call to action Save is never held back.
+ */
+export declare function callToActionSatisfied(callToAction: EditorPrefill['callToAction'], draft: {
+    patientId?: string;
+    operatorId?: string;
+}): boolean;
+/** Confirm a waiting appointment in place; other rows untouched. */
+export declare function confirmAppointment(rows: readonly CalendarRow[], eventId: string): CalendarRow[];
+/** What the waiting-list rail sub-view is showing: the queue, or the
+ *  entry form (add when `entry` is absent, edit when present). */
+export type BacklogSubView = {
+    kind: 'queue';
+} | {
+    kind: 'form';
+    entry?: CalendarWaitingEntry;
+};
+/** What the entry form commits — the journey assigns the id on add. */
+export interface WaitingEntryDraft {
+    id?: string;
+    patientId?: string;
+    operatorId?: string;
+    colorHex: string;
+    description?: string;
+}
+/** Platform AddModal rule: an entry needs a patient OR a description. */
+export declare function waitingEntryIsValid(draft: Pick<WaitingEntryDraft, 'patientId' | 'description'>): boolean;
+/**
+ * Commit the entry form: with an id the matching entry is updated in
+ * place (its link and waiting-since survive); without one a new entry
+ * joins the end of the queue as of the demo's today.
+ */
+export declare function upsertWaitingEntry(list: readonly CalendarWaitingEntry[], draft: WaitingEntryDraft, newId: string): CalendarWaitingEntry[];
+export declare const ANY = "any";
+export declare const FREE_SLOT_CAP = 20;
+export declare const SLOT_STEP_MIN = 30;
+/** Platform `FreeSlot::MAX_DAYS_TO_LOOK_AHEAD` — the finder warns past it. */
+export declare const FREE_SLOT_MAX_RANGE_DAYS = 185;
+/** Whole days between two dates — the finder's range rule. */
+export declare function rangeDays(from: Date, to: Date): number;
+export interface CalendarFreeSlot {
+    start: Date;
+    durationMin: number;
+    chairId: string;
+    operatorId: string;
+    /** The care the search was scoped to — carries name/colour into the
+     *  prefill when a projected slot is clicked on the grid. */
+    careId?: string;
+}
+/** Local ISO date (YYYY-MM-DD) — the fixtures' local-wall-clock idiom;
+ *  absence lookups and shading ids key on local days, never UTC. */
+export declare function localIsoDate(d: Date): string;
+/** The closed complement of one day's working range — up to two
+ *  segments (midnight→open, close→midnight); a closed day (undefined
+ *  hours) is one full-day segment. Minutes from local midnight. */
+export declare function dayComplement(hours: CalendarDayHours | undefined): Array<{
+    startMin: number;
+    endMin: number;
+}>;
+/** Intersect an operator's day with the practice's — closed (undefined)
+ *  when either side is closed or the overlap is empty. */
+export declare function intersectDayHours(a: CalendarDayHours | undefined, b: CalendarDayHours | undefined): CalendarDayHours | undefined;
+/**
+ * Project the COMPLEMENT of the business hours as background events
+ * (`unavail-` ids — distinct from the find-slots glow's `avail-`
+ * namespace): chair and plain axes shade outside the PRACTICE hours;
+ * the operator axis shades outside each operator's own hours
+ * (intersected with the practice's), with absence days
+ * (`data.operatorAbsences`) washing that operator's whole column.
+ * Untitled ON PURPOSE: a titled isInternal event renders the Calendar's
+ * "✓ Free" bookable chip — these washes are decorative unavailability,
+ * painted by FC's own `.fc-bg-event` rule through the
+ * `--fc-bg-event-color` override on the Calendar's className.
+ */
+export declare function buildUnavailabilityEvents(args: {
+    axisKind: DisplaySettings['resourceKind'];
+    rangeStart: Date;
+    rangeEnd: Date;
+    visibleChairIds: string[];
+    visibleOperatorIds: string[];
+    /** True only when `hiddenDates` actually removes the absent column —
+     *  the kit honours it in `resourceTimeGrid*` (vertical) views only. */
+    columnsHiddenWhenAbsent: boolean;
+    /** Month: daygrid paints a background fill for day-spanning events
+     *  only, so emit ONE all-day wash per fully closed day and nothing for
+     *  a partial day (a timed slice renders no fill there). */
+    wholeDayOnly?: boolean;
+}, data: CalendarData): CalendarEvent[];
+export declare const CLOSURE_HOLIDAY_ACCENT = "var(--warning)";
+/** Closure banners (closed date · holiday · operator absence) share one
+ *  id prefix — the peek and click handlers route on it. */
+export declare function isClosureEvent(event: CalendarEvent): boolean;
+/**
+ * All-day closure banners, one per visible column (platform: one closeDay
+ * event per resource) — chair/operator axes need a resourceId or FC drops
+ * the event; `'none'` (plain axis, and Month later) gets one resource-less.
+ */
+export declare function buildClosureBanners(args: {
+    axisKind: DisplaySettings['resourceKind'];
+    rangeStart: Date;
+    rangeEnd: Date;
+    visibleChairIds: string[];
+    visibleOperatorIds: string[];
+    /** The absent column is already gone via `hiddenDates` — no banner. */
+    columnsHiddenWhenAbsent: boolean;
+    labels: {
+        closed: string;
+        holiday: (name: string) => string;
+        absence: (title?: string) => string;
+    };
+}, data: CalendarData): CalendarEvent[];
+export interface PrintRow {
+    id: string;
+    start: Date;
+    end?: Date;
+    allDay: boolean;
+    /** Masked exactly like the grid card under the privacy toggle. */
+    patientName: string;
+    /** Every labelled number; empty under privacy. */
+    phones: CalendarPhoneNumber[];
+    /** Free-text description (platform `name`) — unmasked, like the card. */
+    description?: string;
+    /** Care entries with their tooth elements — unmasked, like the card. */
+    careLines: CalendarCareEntry[];
+    chairId?: string;
+    operatorId?: string;
+    status?: CalendarEventStatus;
+    /** An online booking still without a patient record. */
+    unassigned: boolean;
+}
+export interface PrintGroup {
+    id: string;
+    kind: 'chair' | 'operator' | 'all' | 'no-operator';
+    title?: string;
+    rows: PrintRow[];
+}
+/** Closed date · holiday · operator absence (the closures vocabulary),
+ *  plus the plain non-working weekday the full Week view shows. */
+export type PrintDayNote = CalendarClosure | {
+    kind: 'nonWorking';
+};
+export interface PrintDaySection {
+    date: Date;
+    groups: PrintGroup[];
+    tasks: Array<{
+        id: string;
+        start: Date;
+        allDay: boolean;
+        title: string;
+    }>;
+    notes: PrintDayNote[];
+}
+export interface PrintSheetInput {
+    rows: CalendarRow[];
+    days: Date[];
+    axisKind: DisplaySettings['resourceKind'];
+    visibleChairIds: string[];
+    visibleOperatorIds: string[];
+    privacy: boolean;
+}
+/** A date-only start (all-day rows) is already a local day; anything
+ *  else parses as the wall clock the fixtures and the editor write. */
+export declare function parseEventDate(value: string | Date): Date;
+export declare function maskedTitle(event: CalendarEvent, privacy: boolean): string;
+export declare function printRowOf(row: CalendarRow, privacy: boolean, data: CalendarData): PrintRow;
+export declare function byStart(a: PrintRow, b: PrintRow): number;
+/**
+ * One section per printable day: the appointments the grid would show
+ * (same chair/operator filter), grouped by the active axis, plus the
+ * day's tasks and closure notes for the footer. Ids and keys only — the
+ * sheet localises, so this stays unit-testable.
+ */
+export declare function buildPrintSheet(input: PrintSheetInput, data: CalendarData): PrintDaySection[];
+export declare const PRINT_LINE_PX = 26;
+export declare const PRINT_ROW_PAD_PX = 10;
+/** Characters per wrapped line of free text in the cares column. */
+export declare const PRINT_WRAP_CHARS = 22;
+/** Cells and headers tighten to the small step — the sheet has to fit an
+ *  A4 portrait; the var is read on the cell itself, so no cascade fight. */
+export declare const PRINT_CELL_CLASS = "ds:[--ag-cell-horizontal-padding:var(--spacing-sm)]";
+/** Every line the two stacked cells need; `minLines` lets the plain axis
+ *  reserve the two-line chair / operator cell. */
+export declare function printRowHeight(row: PrintRow, minLines?: number): number;
+export declare function closureReason(t: TFunction, locale: string, closure: CalendarClosure, date: Date, data: CalendarData): string;
+/** External seeding for the finder — e.g. the waiting list's per-entry
+ *  "find slots" action prefills the filters AND carries the patient
+ *  (plus care text/colour) through to the Book prefill. */
+export interface FindSlotsSeed {
+    tick: number;
+    operatorId?: string;
+    chairId?: string;
+    durationMin?: number;
+    patientId?: string;
+    care?: string;
+    /** A linked appointment's cares — ride into Book as linked cares. */
+    cares?: CalendarCareEntry[];
+    colorHex?: string;
+    /**
+     * Set when the search is a RESCHEDULE: booking a slot must move this
+     * appointment rather than create a second one.
+     */
+    rescheduleEventId?: string;
+    /** The waiting entry the search came from — cleared once it is booked. */
+    waitingEntryId?: string;
+}
+/** Booking context that rides ALONG with a projection — so booking by
+ *  clicking a green range on the GRID prefills the same patient/care
+ *  the panel's own Book button would. */
+export type AvailabilityContext = Pick<FindSlotsSeed, 'patientId' | 'care' | 'cares' | 'colorHex'>;
+/**
+ * The in-memory free-slot search over the fixture week: closed dates and
+ * holidays yield nothing, an operator away that day drops out of it, and
+ * a slot clashes with any row on its chair or a non-task row's operator.
+ */
+export declare function searchFreeSlots(args: {
+    rows: CalendarRow[];
+    chairs: readonly CalendarResource[];
+    operators: readonly CalendarResource[];
+    durationMin: number;
+    fromDate: Date;
+    toDate: Date;
+    careId?: string;
+}, data: CalendarData): CalendarFreeSlot[];
+//# sourceMappingURL=calendar.model.d.ts.map