/**
 * 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 { type CalendarEvent, type CalendarEventStatus, type CalendarResource } from '../../components/calendar';
import type { WorkflowStatusTone } from '../../components/workflow-status';
import { APPOINTMENT_STATE_WORKFLOW } from '../../components/_shared/entity-card';
import { APPOINTMENT_STATUS_BADGE_VARIANT } from '../../components/appointment-details-panel/appointment-details-panel.identity';
import type { AppointmentRecurrenceFrequency } from '../../components/appointment-details-panel';
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, type CatalogueState, type PatientRef } 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 (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.
 */
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;
/** The reference for one patient id — the record when the host could
 *  answer, and always the id itself. */
export declare function patientRefById(id: string | number | null | undefined, data: CalendarData): PatientRef;
/** The reference for the patient an appointment carries. */
export declare function eventPatientRef(event: CalendarEvent, data: CalendarData): PatientRef;
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;
    /** Optional for saved preferences and older consumers. @default 'compact' */
    slotDensity?: 'compact' | 'comfortable';
    /** Picker colour strength. @default 'tinted' */
    eventColorStyle?: 'solid' | 'tinted';
    /** Show the opposite resource on tall cards. @default false */
    showCardContext?: 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 { DETAIL_STAMP_FORMAT, formatDay, formatTimeRange, parseEventDate, RECURRENCE_LABEL_KEY, sortHistoryNewestFirst, } from '../../components/_shared/appointment-format';
/** 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;
/** Per-appointment capabilities from the host's canonical read. Omitted
 * capabilities preserve the existing editor behaviour. Locked fields
 * are omitted from drafts, so the host must preserve their stored values. */
export interface CalendarEditorCapabilities {
    editCare?: boolean;
    editPatient?: boolean;
    editDescription?: boolean;
    editRecurrence?: boolean;
    /** 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' | 'chair';
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;
    /** Create only: seeds the repeat fields, a Custom rule included, for a
     *  host that reopens a draft. Ignored on an edit, whose rule is fixed. */
    recurrence?: EditorRecurrence;
    /** 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;
    /** A pure ROUTING flag, not a presentational one: this kit has no
     *  task-editor panel of its own, so nothing currently sets it and the
     *  appointment editor does not read it. Reserved for the task-editor
     *  PR (stacked on the calendar toolbar work) to route a future
     *  "Nuova attività" hand-off to its own panel instead of this one. */
    isTask?: boolean;
}
/** Platform's six `recurrence_frequency` values, in its dropdown order. */
export type RecurrenceFrequency = AppointmentRecurrenceFrequency;
/** 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[];
/** RRULE weekday codes, indexed by JS `getDay()` (0 = Sunday). */
export declare const RECURRENCE_WEEKDAYS: readonly ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
export type RecurrenceWeekday = (typeof RECURRENCE_WEEKDAYS)[number];
/** One RRULE BYDAY token: a plain weekday (weekly rules) or a weekday
 *  with its place in the month, `3TU` the third Tuesday and `-1TU` the
 *  last one (monthly rules). */
export type RecurrenceByDay = RecurrenceWeekday | `${1 | 2 | 3 | 4 | -1}${RecurrenceWeekday}`;
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'`: the
     *  picked calendar day at local midnight. Platform `recurrenceUntil`
     *  wants the END of that day: RRULE UNTIL at midnight drops that day's
     *  occurrence, and `setRecurrenceUntil()` refuses a value before the
     *  appointment's own start. */
    untilDate?: Date;
    /** Beyond platform: drop occurrences the practice could not honour. */
    skipClosedDays: boolean;
    /** Every N steps of `frequency`: platform `recurrenceInterval` (RRULE
     *  INTERVAL). Absent means 1. Only the Custom rule sets it, and only
     *  with `daily`, `weekly`, `monthly` or `yearly`. */
    interval?: number;
    /** Platform `recurrenceByDay` (RRULE BYDAY), set by the Custom rule
     *  only. Weekly: plain codes in week order, always including the first
     *  appointment's own day (`['MO', 'TH']`). Monthly: one ordinal code
     *  derived from the first appointment (`['3TU']`, `['-1TU']`). Absent
     *  means the plain rule. PLATFORM CAVEAT: `setRecurrenceFrequency()`
     *  empties `recurrenceByDay` unless the frequency is weekly or yearly,
     *  so a monthly code survives only if `setRecurrenceByDay()` runs after
     *  it (or that setter changes). No platform controller writes
     *  `recurrenceInterval` or `recurrenceByDay` from the calendar today. */
    byDay?: readonly RecurrenceByDay[];
}
/** Where a date's weekday falls in its month: `nth` 1–5 counted from the
 *  start, `last` when no later same weekday fits in the month. */
export declare function weekdayOfMonth(date: Date): {
    nth: number;
    last: 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'>;
/** Live stamps advance from the practice clock, never the real one. */
export declare function historyStampIso(seq: number, data: CalendarData): string;
/** 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;
}>>;
/** Whether the host gave us a price-list catalogue at all: `ready`,
 *  `none` (told, and empty) or `unknown` (never told). Both non-ready
 *  states withhold the "From price list" relation — see the CATALOGUE
 *  PRESENCE note in `calendar.types.ts`. */
export declare function priceListState(data: CalendarData): CatalogueState;
/** The patient's price list by name, else the practice default —
 *  `undefined` when there is no catalogue to default into. The absence
 *  is RETURNED, never papered over: a fabricated id would name a price
 *  list the practice does not have, and `priceLists[0].id` on an empty
 *  catalogue threw and took the whole calendar down with it. */
export declare function priceListIdFor(patientId: string | undefined, data: CalendarData): string | undefined;
type StatusChip = {
    variant: (typeof APPOINTMENT_STATUS_BADGE_VARIANT)[CalendarEventStatus];
    tone: WorkflowStatusTone;
    Icon: (typeof APPOINTMENT_STATE_WORKFLOW)[CalendarEventStatus]['Icon'];
};
export declare const STATUS_CHIP: Record<CalendarEventStatus, StatusChip>;
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),
 *  as the reference: `assigned` says whether anyone is booked at all,
 *  which is what a "no patient" label may key on — never the record. */
export declare function backlogPatientRef(item: BacklogItem, data: CalendarData): PatientRef;
/** The record behind a queue row, when the host could load it. */
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, 
/** Localised stand-in while the host is still fetching the row's
 *  details — such a row carries no title of its own. */
pendingDetailsLabel?: string): 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 patient pre-selected — the id the booking
 * already carries, or a typed-name match — and BOTH the patient and the
 * operator marked required, the two things it needs to leave 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;
/** The From→To span the finder opens on — the platform's own default. */
export declare const FREE_SLOT_DEFAULT_HORIZON_DAYS = 30;
/** 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;
    /** The device a SERVER answer allocated: the host's own string. */
    medicalDeviceId?: 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;
}
/** The title privacy mode shows. TOTAL in the masked branch: a host
 *  that supplies an EMPTY `privacyModeTitle` gets the bullets, never a
 *  blank and never a fallback that would leak what we do or do not hold
 *  on the one surface whose job is to say nothing. */
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'> & {
    /** Optional search scope, retained for resource-axis consumers. */
    scopeOperatorId?: string;
    scopeChairId?: string;
};
/** One painted free range — see `mergeAvailabilityRanges`. */
export interface AvailabilityRange {
    /** Stable per range: `<resource or day>:<start ms>`. */
    key: string;
    start: Date;
    end: Date;
    /** The column the range belongs to on a resource axis. */
    resourceId?: string;
}
/**
 * Found slots as CONTIGUOUS ranges: one per resource on the chair and
 * operator axes, one per day on the plain grid. Touching or overlapping
 * slots collapse into a single range with a single label. The search
 * emits one slot per chair x operator pair at every step, so painting
 * them one by one stacks chips at the same minute and lights every step
 * of the day where any pair is free.
 */
export declare function mergeAvailabilityRanges(slots: readonly CalendarFreeSlot[], axisKind: 'none' | 'chair' | 'operator'): AvailabilityRange[];
export interface CalendarFreeBand extends AvailabilityRange {
    /** Original bookable answers, in finder order, never a fabricated union slot. */
    options: readonly CalendarFreeSlot[];
    /** Distinct chair x operator combinations, not the number of start times. */
    optionCount: number;
}
/** Union free time per local day while retaining the original booking choices. */
export declare function buildFreeBands(slots: readonly CalendarFreeSlot[]): CalendarFreeBand[];
export interface AvailabilitySlotCell extends AvailabilityRange {
    /** Distinct chair x operator combinations sharing this exact
     *  start + duration (+ resource column, on a resource axis). */
    optionCount: number;
}
/**
 * One cell per DISTINCT start + duration, not a merged band: the grid
 * projection ("Show in calendar") highlights individual bookable slots
 * rather than one filled range spanning everything free. On `'none'` the
 * key is the slot's own start + duration, deduped across every chair x
 * operator pair; on a resource axis the key also carries the resource, so
 * two touching slots in the same column stay two cells, never merged into
 * one (unlike `mergeAvailabilityRanges`). `buildFreeBands` is untouched —
 * the finder's own list still unions by day, this is grid painting only.
 */
export declare function buildFreeSlotCells(slots: readonly CalendarFreeSlot[], axisKind: 'none' | 'chair' | 'operator'): AvailabilitySlotCell[];
/**
 * The in-memory free-slot search over the loaded rows: closed dates and
 * holidays yield nothing, an operator away that day drops out of it, an
 * operator with hours of their own is held to them, a per-date closure
 * (`closedIntervals`) is never offered over, a day the host is still
 * loading (`dayLoadState`) is not answered from at all, 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