@medplum/react-scheduling 5.1.37 → 5.1.39

package/dist/esm/index.d.ts

@@ -1,4 +1,6 @@
 import type { Appointment } from '@medplum/fhirtypes';
+import type { Coding } from '@medplum/fhirtypes';
+import type { Dereference } from '@medplum/core';
 import type { HealthcareService } from '@medplum/fhirtypes';
 import type { HealthcareServiceAvailableTime } from '@medplum/fhirtypes';
 import type { JSX } from 'react';
@@ -7,16 +9,18 @@ import type { MantineThemeColors } from '@mantine/core';
 import type { MedplumClient } from '@medplum/core';
 import type { OperationOutcome } from '@medplum/fhirtypes';
 import type { Patient } from '@medplum/fhirtypes';
+import type { ReactNode } from 'react';
 import type { Reference } from '@medplum/fhirtypes';
-import type { Resource } from '@medplum/fhirtypes';
 import type { Schedule } from '@medplum/fhirtypes';
+import type { SchedulingRequirement } from '@medplum/core';
 import type { Slot } from '@medplum/fhirtypes';
+import type { ValueSetExpansionContains } from '@medplum/fhirtypes';
 import type { WithId } from '@medplum/core';
 
 /**
  * One way of holding an appointment: a set of actors whose schedules `$find`
- * intersects in a single request. A role contributes as many actors as were
- * chosen for it, since everything chosen attends.
+ * intersects in a single request. Each requirement contributes exactly one
+ * actor, since a row is satisfied by any one of its alternatives.
  */
 export declare interface ActorCombination {
     /** Matches `getActorGroupKey` of the appointments offered for these actors. */
@@ -27,29 +31,72 @@ export declare interface ActorCombination {
 }
 
 /**
- * What an appointment is being asked for: the schedules chosen, per role.
- * Everything named attends.
+ * One thing an appointment needs, of a single actor type.
+ *
+ * The candidates in it are alternatives: a row naming two
+ * providers asks for *either* of them rather than both.
+ */
+export declare interface ActorRequirement {
+    readonly id: string;
+    readonly candidates: readonly ScheduleCandidate[];
+}
+
+/**
+ * What an appointment is being asked for, per actor type.
+ *
+ * Each actor type holds a list of requirements, and the two directions read
+ * differently: requirements are ANDed, so two provider rows ask for two
+ * providers, while the candidates within one row are ORed.
  */
-export declare type ActorSelections = Partial<Record<SchedulingRole, readonly ScheduleCandidate[]>>;
+export declare type ActorSelections = Partial<Record<SchedulingActorType, readonly ActorRequirement[]>>;
 
 export declare function addDays(date: Date, days: number): Date;
 
 /**
- * Chooses the actors an appointment is held on, for one role.
+ * Chooses which actors of one type can hold an appointment.
  *
- * Everything chosen attends: `$find` intersects the schedules behind them,
- * so naming a second actor narrows the times to the ones both are free for.
+ * The names in one of these fields are **alternatives** to each other.
+ * Several actors that all have to attend go in a field each - see {@link AppointmentActorSelections},
+ * which arranges these into rows.
  *
- * Schedules are searched for as the name is typed (via `AsyncAutocomplete`).
+ * The results are `Schedule` resources, bound to the actors that can hold the appointment.
  *
  * @param props - The React props.
- * @returns The field for one role.
+ * @returns The field for one actor type.
  */
 export declare function AppointmentActorSelect(props: AppointmentActorSelectProps): JSX.Element;
 
+/**
+ * Asks what an appointment needs by actor type (e.g., provider, room, device).
+ *
+ * Each actor type gets a stack of rows. **The rows are ANDed and the names
+ * within a row are ORed**: two provider rows ask for two providers, while two
+ * names in one row ask for either of them.
+ *
+ * A row is one alternative set, so it is also one dimension of the search:
+ * `getActorCombinations` takes one name from each row, and every way of doing
+ * that is one `$find` request.
+ *
+ * @param props - The React props.
+ * @returns One group of rows per bookable actor type.
+ */
+export declare function AppointmentActorSelections(props: AppointmentActorSelectionsProps): JSX.Element;
+
+export declare interface AppointmentActorSelectionsProps {
+    /** What the appointment is being asked for so far, per actor type. */
+    readonly value: ActorSelections;
+    /** The service being booked. Nothing is offered until it resolves. */
+    readonly service: Reference<HealthcareService> | WithId<HealthcareService> | undefined;
+    /** The site being booked at. Actors sited elsewhere are left out. */
+    readonly location?: Reference<Location_2> | WithId<Location_2>;
+    readonly disabled?: boolean;
+    /** What is wrong with a type's rows, shown under them. None by default. */
+    readonly errors?: Partial<Record<BookableActorType, string>>;
+    readonly onChange: (selections: ActorSelections) => void;
+}
+
 export declare interface AppointmentActorSelectProps {
-    /** The role being filled. */
-    readonly role: SchedulingRole;
+    readonly actorType: BookableActorType;
     /** The service being booked. Nothing is offered until it resolves. */
     readonly service: Reference<HealthcareService> | WithId<HealthcareService> | undefined;
     /**
@@ -62,6 +109,16 @@ export declare interface AppointmentActorSelectProps {
     readonly onChange: (candidates: readonly ScheduleCandidate[]) => void;
     readonly error?: string;
     readonly disabled?: boolean;
+    /** Names the field. Defaults to the actor type's own label. */
+    readonly label?: ReactNode;
+    /** The line under the field. None by default. */
+    readonly description?: ReactNode;
+    /** What the empty field invites. Defaults to searching the actor type by name. */
+    readonly placeholder?: string;
+    /** Whether the field must be answered. Defaults to whether its actor type is required. */
+    readonly required?: boolean;
+    /** Whether to mark the field with an asterisk. Defaults to `required`. */
+    readonly withAsterisk?: boolean;
 }
 
 /** What a booking wrote, as `Appointment/$book` returned it. */
@@ -124,6 +181,7 @@ export declare interface AppointmentDayTimesProps {
     readonly onSelectAppointment: (appointment: Appointment) => void;
     /** IANA timezone the times are read in. Defaults to the browser's. */
     readonly timezone?: string;
+    readonly viewerTimezone?: string;
     readonly selected?: Appointment;
 }
 
@@ -145,13 +203,6 @@ export declare interface AppointmentOptionRowProps {
  * Gathers what a visit is held on, finds a time every one of them is free, and
  * hands the proposal out to be booked.
  *
- * One field per scheduling role, each searching the schedules bookable for the
- * chosen visit type. Everything named attends, because `$find` intersects their
- * schedules — so naming a second room narrows the times rather than widening them.
- *
- * Only a time the search offered can be chosen: the field holding it accepts no
- * input, so nothing can be booked onto time nobody checked availability for.
- *
  * Writes nothing and announces nothing: `onBook` owns that. Mount this to do
  * something other than `$book` with the proposal — hold it through `$hold`, or
  * write it inside a transaction of your own. {@link AppointmentBookingForm} is the
@@ -200,6 +251,10 @@ export declare interface AppointmentProposalFormProps {
      * rather than leaving it on a time nobody chose.
      */
     readonly onChangeTime?: (time: DateTimeRange | undefined) => void;
+    /** The ValueSet the procedure code field binds to. Defaults to the full CPT value set. */
+    readonly procedureBinding?: string;
+    /** The ValueSet the diagnosis code field binds to. Defaults to the full ICD-10-CM value set. */
+    readonly diagnosisBinding?: string;
     /**
      * Performs the booking with the proposal the form assembled.
      *
@@ -238,7 +293,7 @@ export declare interface AppointmentServiceSelectProps {
 export declare interface AppointmentSlotGroup {
     /** Stable key derived from the actors, so React keys survive a refetch. */
     readonly key: string;
-    readonly actors: readonly SchedulingActor[];
+    readonly actors: readonly SchedulingActorValue[];
     readonly durationMinutes: number;
     /** Sorted by start time. */
     readonly appointments: readonly Appointment[];
@@ -254,23 +309,43 @@ export declare function AppointmentSlotGroupCard(props: AppointmentSlotGroupCard
 export declare interface AppointmentSlotGroupCardProps {
     readonly group: AppointmentSlotGroup;
     readonly onSelectAppointment: (appointment: Appointment) => void;
-    /** IANA timezone the times are shown in. Defaults to the browser's. */
+    /** Timezone the times are shown in. */
     readonly timezone?: string;
+    /** The viewer's own timezone. */
+    readonly viewerTimezone?: string;
     readonly selected?: Appointment;
     readonly disabled?: boolean;
 }
 
 /**
- * Actor types whose schedules may be offered for booking.
+ * Actor types whose schedules may be offered for booking, in the order they are
+ * asked about.
  *
- * Does not include `PractitionerRole` to prevent double-booking
- * a `Practitioner` who holds multiple roles. See `getSchedulingRole` for how
- * `PractitionerRole` is still used to determine eligibility for a schedule.
+ * Each type becomes its own question, because `$find` intersects the schedules it
+ * is given: a time is offered only when the practitioner *and* the location *and*
+ * the device are all free for it. Asking for *either* of two practitioners is a
+ * second request rather than a second schedule on the same one — see
+ * `getActorCombinations`.
+ *
+ * Does not include `PractitionerRole` to prevent double-booking a `Practitioner`
+ * who holds multiple roles. A practitioner is booked on their `Practitioner`,
+ * but their `PractitionerRole`s still decide which schedules they are eligible
+ * for and where they practice.
  */
-export declare const BOOKABLE_ACTOR_TYPES: readonly ["Practitioner", "Location", "Device"];
+export declare const BOOKABLE_ACTOR_TYPES: ["Practitioner", "Location", "Device"];
 
 export declare type BookableActorType = (typeof BOOKABLE_ACTOR_TYPES)[number];
 
+/**
+ * What the booking form captures for a visit type's requirements: one value per requirement it
+ * can be asked for.
+ */
+export declare interface BookingRequirementValues {
+    readonly procedure: readonly Coding[];
+    readonly diagnosis: readonly Coding[];
+    readonly medicalNecessity: boolean;
+}
+
 export declare function Calendar(props: CalendarProps): JSX.Element;
 
 export declare interface CalendarProps {
@@ -299,6 +374,26 @@ declare interface CommonProps {
     readonly onCancel?: () => void;
 }
 
+/**
+ * Counts the combinations the selections expand into, without building them.
+ *
+ * An upper bound rather than an exact count: the ones that would name the same
+ * actor twice are only recognised while building. Enough to decide whether the
+ * product is worth expanding at all.
+ *
+ * @param selections - What has been chosen.
+ * @returns How many ways there are of satisfying every row, or 0 when nothing
+ *   has been chosen.
+ */
+export declare function countActorCombinations(selections: ActorSelections): number;
+
+/**
+ * Opens a new requirement row.
+ * @param candidates - What it starts out asking for. Empty by default.
+ * @returns The row.
+ */
+export declare function createActorRequirement(candidates?: readonly ScheduleCandidate[]): ActorRequirement;
+
 /** The days a search covers. Either end may be open. */
 export declare interface DateRange {
     readonly start?: Date;
@@ -310,6 +405,14 @@ export declare type DateTimeRange = {
     end: Date;
 };
 
+/** The value set the diagnosis code field binds to when a host names none. */
+export declare const DEFAULT_DIAGNOSIS_VALUE_SET = "http://hl7.org/fhir/sid/icd-10-cm/vs";
+
+/** The value set the procedure code field binds to when a host names none. */
+export declare const DEFAULT_PROCEDURE_VALUE_SET = "http://www.ama-assn.org/go/cpt/vs";
+
+export declare const EMPTY_REQUIREMENT_VALUES: BookingRequirementValues;
+
 /**
  * Returns the last instant of a day, so that a range covers the whole of it.
  * @param date - Any instant during the day.
@@ -360,14 +463,6 @@ export declare interface FilterCandidatesOptions {
     readonly signal?: AbortSignal;
 }
 
-/**
- * Says in words which days a search covers.
- * @param range - The days asked for.
- * @param formatDay - How to name one day. Defaults to naming it with its weekday.
- * @returns The range as a phrase, or undefined when both ends are open.
- */
-export declare function formatDateRange(range: DateRange, formatDay?: (date: Date) => string): string | undefined;
-
 /**
  * Formats a calendar day as a heading (e.g. "Monday, July 27").
  * @param date - Local midnight of the day.
@@ -376,29 +471,41 @@ export declare function formatDateRange(range: DateRange, formatDay?: (date: Dat
 export declare function formatDayHeading(date: Date): string;
 
 /**
- * Names a calendar day without its weekday (e.g. "July 27").
- * @param date - Local midnight of the day.
- * @returns The formatted day.
+ * Names a timezone the short way it is written beside a time, e.g. "ET" or "GMT+2".
+ * @param timezone - IANA timezone identifier. Defaults to the browser's.
+ * @returns The zone's short name.
  */
-export declare function formatDayLabel(date: Date): string;
+export declare function formatTimezoneLabel(timezone?: string): string;
 
 /**
  * Formats an instant's time of day in a given timezone (e.g. "12:30 PM").
  * @param date - The instant to format.
  * @param timezone - IANA timezone identifier. Defaults to the browser's.
+ * @param options - Whether to name the zone as well.
  * @returns The formatted time.
  */
-export declare function formatZonedTime(date: Date, timezone?: string): string;
+export declare function formatZonedTime(date: Date, timezone?: string, options?: FormatZonedTimeOptions): string;
+
+export declare interface FormatZonedTimeOptions {
+    /** Names the zone alongside the time, e.g. "12:30 PM ET". */
+    readonly withTimezone?: boolean;
+}
 
 /**
  * Builds the sets of actors an appointment could be held on.
  *
  * One combination is one `$find` request: the schedules within it are
- * intersected, so its times are the times all of those actors are free.
+ * intersected, so its times are the times all of those actors are free. Rows are
+ * ANDed and the alternatives within a row are ORed, so the combinations are the
+ * product of the rows — one alternative taken from each.
+ *
+ * Ordered as an odometer with the last row turning fastest, so the first
+ * combination is every row's first pick and the rounds the search runs stay
+ * predictable.
  *
  * @param selections - What has been chosen.
- * @returns One combination holding every chosen actor, in role order, or an
- *   empty list when nothing is chosen.
+ * @returns One combination per way of satisfying every row, or an empty list
+ *   when nothing is chosen.
  */
 export declare function getActorCombinations(selections: ActorSelections): ActorCombination[];
 
@@ -410,22 +517,39 @@ export declare function getActorCombinations(selections: ActorSelections): Actor
 export declare function getActorGroupKey(appointment: Appointment): string;
 
 /**
- * Names the role an actor is filling, from its own reference.
+ * Builds a key identifying a set of actors, independent of their order.
+ * @param actors - The actors to key.
+ * @returns The key.
+ */
+export declare function getActorsKey(actors: readonly Reference[]): string;
+
+/**
+ * Extracts the resource type of an actor, given as itself or as a reference.
  *
- * Needed where an actor is shown away from the field it was chosen in, which is
- * the only thing that would otherwise say which role it answers.
+ * Only supports references that may be used for Scheduling operations, which are
+ * those that have a qualified `reference` attribute. The attribute must be present,
+ * and may not be a reference to a "contained" resource (eg. `{ reference: "#cid" }`)
  *
- * @param actor - A reference to a scheduling actor.
- * @returns The role's label, or undefined for a reference of another type.
+ * @param actor - A schedulable resource, or a Reference to one
+ * @returns The type of the actor.
  */
-export declare function getActorRoleLabel(actor: Reference): string | undefined;
+export declare function getActorType(actor: SchedulingActorValue): SchedulingActorType;
 
 /**
- * Builds a key identifying a set of actors, independent of their order.
- * @param actors - The actors to key.
- * @returns The key.
+ * Provides the label we use for scheduling resource types in this UI
+ *
+ * @param resourceType - A scheduling actor type
+ * @returns The type's label
  */
-export declare function getActorsKey(actors: readonly Reference[]): string;
+export declare function getActorTypeLabel(resourceType: SchedulingActorType): string;
+
+/**
+ * Get the actor(s) of an appointment.
+ * @param appointment - The proposed appointment.
+ * @param actorResources - Map of actor resources that have already been previously loaded.
+ * @returns List of actors. Resource if it's already loaded, reference otherwise.
+ */
+export declare function getAppointmentActors(appointment: Appointment | undefined, actorResources?: ReadonlyMap<string, SchedulingActorResource>): SchedulingActorValue[];
 
 /**
  * Returns a key uniquely identifying a proposed appointment.
@@ -439,18 +563,24 @@ export declare function getActorsKey(actors: readonly Reference[]): string;
 export declare function getAppointmentKey(appointment: Appointment): string;
 
 /**
- * Names a candidate's actor, for use in plain-text option lists.
- * @param candidate - The candidate to name.
- * @returns The name to show.
+ * The IANA timezone the browser is set to.
+ * @returns The viewer's own timezone identifier.
  */
-export declare function getCandidateDisplay(candidate: ScheduleCandidate): string;
+export declare function getBrowserTimezone(): string;
 
 /**
- * Returns the role a candidate fills, from the type of its actor.
+ * Returns the actor a candidate's schedule is held on.
  * @param candidate - The candidate to read.
- * @returns The role, or undefined for an actor of a type nothing books against.
+ * @returns Its schedule's only actor.
  */
-export declare function getCandidateRole(candidate: ScheduleCandidate): SchedulingRole | undefined;
+export declare function getCandidateActor(candidate: ScheduleCandidate): SchedulingActor;
+
+/**
+ * Names a candidate's actor, for use in plain-text option lists.
+ * @param candidate - The candidate to name.
+ * @returns The name to show.
+ */
+export declare function getCandidateDisplay(candidate: ScheduleCandidate): string;
 
 /**
  * Counts the days a window covers, a part of a day counting as a whole one.
@@ -510,25 +640,49 @@ export declare function getFindWindowError(range: DateRange): string | undefined
 export declare function getNativeInputType(type: 'date' | 'time'): string;
 
 /**
- * Returns the role an actor type is chosen as.
- * @param actorType - A `Schedule.actor` resource type.
- * @returns The role that actor fills.
+ * Returns every row across every actor type, in the order they are asked about.
+ * @param selections - What has been chosen.
+ * @returns The rows, empty ones included.
  */
-export declare function getSchedulingRole(actorType: SchedulingActorType): SchedulingRole;
+export declare function getRequirements(selections: ActorSelections): ActorRequirement[];
 
 /**
- * Returns everything chosen, across roles.
+ * Flattens the loaded actor resources into a map, keyed by their reference.
  * @param selections - What has been chosen.
- * @returns The chosen candidates, in `SCHEDULING_ROLES` order.
+ * @returns The resource behind each chosen actor the search was able to include.
+ */
+export declare function getSelectedActorResources(selections: ActorSelections): Map<string, SchedulingActorResource>;
+
+/**
+ * Returns everything chosen, across rows and actor types.
+ * @param selections - What has been chosen.
+ * @returns The chosen candidates in `BOOKABLE_ACTOR_TYPES` order, then row order.
  */
 export declare function getSelectedCandidates(selections: ActorSelections): ScheduleCandidate[];
 
 /**
  * Reports why the current selections cannot be searched, if they cannot.
  * @param selections - What has been chosen.
- * @returns A message to show the user, or undefined when the search can run.
+ * @returns The blocker to show the user, or undefined when the search can run.
+ */
+export declare function getSelectionError(selections: ActorSelections): SelectionBlocker | undefined;
+
+/**
+ * Finds the rows that cannot all be filled at once, when there are any. Specifically happens
+ * when two rows offer the same resource, so one resource cannot fill both halves of a visit.
+ * @param selections - What has been chosen.
+ * @returns The first type whose rows have no answer between them, or undefined when
+ *   every type can be satisfied.
  */
-export declare function getSelectionError(selections: ActorSelections): string | undefined;
+export declare function getUnsatisfiableRows(selections: ActorSelections): UnsatisfiableRows | undefined;
+
+/**
+ * Search window for a calendar day in the given timezone, starting from now if that day is already underway.
+ * @param day - The day to search, as local midnight. Bound to the site's timezone.
+ * @param timezone - IANA timezone identifier. Defaults to the browser's.
+ * @returns Range from the start of that day, or from now, through the next day's midnight.
+ */
+export declare function getZonedDayRange(day: Date, timezone?: string): Required<DateRange>;
 
 /**
  * Groups proposed appointments into days, and each day into the sets of actors
@@ -539,28 +693,53 @@ export declare function getSelectionError(selections: ActorSelections): string |
  * @param searched - Days to list whether or not they offer anything, so a searched day
  *   that came back empty still shows up rather than going missing. Read on the local
  *   calendar, matching how a day is picked.
+ * @param actorResources - The actors' own resources, keyed by reference, for
+ *   whichever of them the caller has already read. See {@link getAppointmentActors}.
  * @returns Days in ascending order, each holding its groups.
  */
-export declare function groupAppointmentsByDay(appointments: readonly Appointment[], timezone?: string, searched?: DateRange): AppointmentDay[];
+export declare function groupAppointmentsByDay(appointments: readonly Appointment[], timezone?: string, searched?: DateRange, actorResources?: ReadonlyMap<string, SchedulingActorResource>): AppointmentDay[];
 
-export declare function isBookableActorType(value: string | undefined): value is BookableActorType;
+/**
+ * Whether every requirement a visit type names has been answered.
+ * @param values - What the fields are holding.
+ * @param requirements - What the visit type requires, from its eligibility codes.
+ * @returns True once each required field holds a value. A value nothing asked for is not weighed.
+ */
+export declare function hasRequiredValues(values: BookingRequirementValues, requirements: ReadonlySet<SchedulingRequirement>): boolean;
 
 /**
- * Reports whether a role has to be filled.
- * @param role - The role being filled.
+ * Reports whether an actorType has to be chosen to be a valid booking
+ * @param actorType - The actor type being chosen.
  * @returns Whether a search can run without it.
  */
-export declare function isRoleRequired(role: SchedulingRole): boolean;
+export declare function isActorTypeRequired(actorType: SchedulingActorType): boolean;
+
+export declare function isBookableActorType(value: string | undefined): value is BookableActorType;
+
+/**
+ * Whether one requirement has been answered.
+ * @param requirement - The requirement to weigh.
+ * @param values - What the fields are holding.
+ * @returns True when the field answering that requirement holds a value.
+ */
+export declare function isRequirementAnswered(requirement: SchedulingRequirement, values: BookingRequirementValues): boolean;
 
 /**
- * Returns whether two instants fall on the same local day.
- * @param left - The first instant.
- * @param right - The second, or undefined when there is nothing to compare.
- * @returns True when both fall on the same local day.
+ * Whether a timezone is the viewer's own.
+ * @param timezone - IANA timezone the times are in, or undefined when it could not be resolved.
+ * @param viewer - The viewer's IANA timezone. Defaults to the browser's
+ * @returns True when the zone is the viewer's, or when there is no zone to compare.
  */
-export declare function isSameDay(left: Date, right: Date | undefined): boolean;
+export declare function isViewerTimezone(timezone: string | undefined, viewer?: string): boolean;
 
-export declare function isSchedulingActorType(value: string | undefined): value is SchedulingActorType;
+/**
+ * The most alternatives worth expanding into requests at all.
+ *
+ * The search runs a few combinations at a time, so this is not the size of a
+ * round: it is the point past which the whole product is more than anyone is
+ * going to sit through, whatever order it is asked in.
+ */
+export declare const MAX_ACTOR_COMBINATIONS = 100;
 
 /**
  * The longest window `Appointment/$find` accepts. Requests wider than this are
@@ -618,7 +797,13 @@ export declare function parseDayKey(key: string): Date;
  */
 export declare function parseZonedTime(day: Date, time: string, timezone?: string): Date | undefined;
 
-export declare const ROLE_LABELS: Record<SchedulingRole, string>;
+/**
+ * Actor types that must be chosen before a search can run.
+ *
+ * Locations and devices are left optional: a service may have location schedules
+ * configured without every booking needing to hold one.
+ */
+export declare const REQUIRED_ACTOR_TYPES: ReadonlySet<SchedulingActorType>;
 
 /**
  * Edits weekly availability for one visit service type, either as a Schedule's
@@ -645,7 +830,7 @@ export declare type ScheduleAvailabilityEditorProps = ScheduleOverrideEditorProp
 export declare interface ScheduleCandidate {
     readonly schedule: WithId<Schedule>;
     /** The actor itself, when the search was able to include it. */
-    readonly actorResource: WithId<Resource> | undefined;
+    readonly actorResource: SchedulingActorResource | undefined;
 }
 
 /**
@@ -660,27 +845,21 @@ export declare interface ScheduleOverrideEditorProps extends CommonProps {
     readonly onSave: (updatedSchedule: Schedule) => void | Promise<void>;
 }
 
-/** Resource types that may appear in `Schedule.actor`. */
-export declare const SCHEDULING_ACTOR_TYPES: readonly ["Practitioner", "PractitionerRole", "Location", "Device"];
-
-/**
- * The parts of an appointment a user chooses, in the order they are asked about.
- *
- * Each role becomes one question, because `$find` intersects the schedules it is
- * given: a time is offered only when the provider *and* the room *and* the
- * device are all free for it.
- */
-export declare const SCHEDULING_ROLES: readonly ["provider", "room", "device"];
-
 /**
  * A reference to something a Schedule belongs to. The same union an Appointment
  * accepts as a participant, so an actor can be carried straight across.
  */
 export declare type SchedulingActor = Schedule['actor'][number];
 
-export declare type SchedulingActorType = (typeof SCHEDULING_ACTOR_TYPES)[number];
+/** A loaded actor resource. */
+export declare type SchedulingActorResource = WithId<Dereference<SchedulingActor>>;
 
-export declare type SchedulingRole = (typeof SCHEDULING_ROLES)[number];
+export declare type SchedulingActorType = SchedulingActorResource['resourceType'];
+
+/**
+ * An actor as a reference, or as the resource when it has already been read.
+ */
+export declare type SchedulingActorValue = SchedulingActor | SchedulingActorResource;
 
 /**
  * A data-coordination component pairing {@link CalendarsPanel} with {@link MultiCalendar}.
@@ -692,6 +871,9 @@ export declare type SchedulingRole = (typeof SCHEDULING_ROLES)[number];
  *   The form writes the booking and announces what it wrote, which is what puts the
  *   new appointment on the calendar beside it — a host supplies no data for any of it.
  *   What was written is reported through `onBooked`, for a host that wants to say so.
+ * - Shows what is booked: clicking an appointment opens {@link AppointmentDetails} in a
+ *   drawer over the calendar, describing the visit and offering to cancel it. Cancelling
+ *   is what takes the time back off the calendar, again without a host supplying anything.
  * - Highlights the time last chosen, wherever it was chosen: the click that opened the
  *   pane, then whatever the form's time search settles on, and nothing while the form
  *   holds no time. The calendar is never moved to reach it — a highlight off the week
@@ -704,7 +886,17 @@ export declare function SchedulingWorkspace(props: SchedulingWorkspaceProps): JS
 
 export declare interface SchedulingWorkspaceProps {
     readonly className?: string;
+    /** The ValueSet the procedure code field binds to. Defaults to full CPT valueset. */
+    readonly procedureBinding?: string;
+    /** The ValueSet the diagnosis code field binds to. Defaults to full ICD-10-CM valueset. */
+    readonly diagnosisBinding?: string;
     readonly onBooked?: (booking: AppointmentBooking) => void | Promise<void>;
+    readonly onCancelled?: (appointment: WithId<Appointment>) => void | Promise<void>;
+    /**
+     * Overrides the value set the appointment detail view offers cancellation reasons
+     * from, for a host coding them against its own terminology.
+     */
+    readonly appointmentCancellationReasonValueSet?: string;
 }
 
 /**
@@ -720,8 +912,8 @@ export declare function searchScheduleCandidates(medplum: MedplumClient, service
 
 export declare interface SearchScheduleCandidatesOptions {
     /** Which of the service's actors to offer. */
-    readonly role: SchedulingRole;
-    /** What the user typed. Empty offers whatever the role has, unfiltered by name. */
+    readonly actorType: SchedulingActorType;
+    /** What the user typed. Empty offers whatever the actor type has, unfiltered by name. */
     readonly query: string;
     /**
      * The site being booked at. Actors sited elsewhere are left out: a room or a
@@ -734,6 +926,20 @@ export declare interface SearchScheduleCandidatesOptions {
     readonly count?: number;
 }
 
+/** Why the current selections cannot be searched. */
+export declare interface SelectionBlocker {
+    /** A whole sentence to show the user. */
+    readonly message: string;
+    readonly severity: SelectionBlockerSeverity;
+}
+
+/**
+ * Whether a blocker is a form that is not finished yet, or answers that cannot work.
+ *
+ * Only `invalid` is the user's to undo, so only it is worth showing as an error.
+ */
+export declare type SelectionBlockerSeverity = 'incomplete' | 'invalid';
+
 /**
  * Props for editing a service's own default hours, in place of any one calendar's override.
  * @param schedule - Omitted, which is what selects this mode.
@@ -778,6 +984,21 @@ export declare function startOfDay(date: Date): Date;
 
 export declare type TimeOfDay = 'any' | 'morning' | 'afternoon';
 
+/**
+ * Reads the codes a field is holding into a list of codings.
+ * @param elements - What the field is holding.
+ * @returns The codings to record, dropping anything that never became a code.
+ */
+export declare function toCodings(elements: readonly ValueSetExpansionContains[]): Coding[];
+
+/** Rows that cannot all be filled at once, and where to say so. */
+export declare interface UnsatisfiableRows {
+    /** The actor type whose rows have no answer between them. */
+    readonly actorType: BookableActorType;
+    /** What to do about it, to show against those rows. */
+    readonly message: string;
+}
+
 /**
  * Searches for the times an appointment could be held at.
  *