@medplum/react-scheduling 5.1.38 → 5.1.40

package/dist/cjs/index.d.ts

@@ -1,6 +1,8 @@
 import type { Appointment } from '@medplum/fhirtypes';
+import type { Bundle } from '@medplum/fhirtypes';
 import type { Coding } from '@medplum/fhirtypes';
 import type { Dereference } from '@medplum/core';
+import type { Extension } from '@medplum/fhirtypes';
 import type { HealthcareService } from '@medplum/fhirtypes';
 import type { HealthcareServiceAvailableTime } from '@medplum/fhirtypes';
 import type { JSX } from 'react';
@@ -9,8 +11,8 @@ 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';
@@ -19,8 +21,8 @@ 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. */
@@ -31,26 +33,70 @@ export declare interface ActorCombination {
 }
 
 /**
- * What an appointment is being asked for: the schedules chosen, per actor type.
- * 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 type ActorSelections = Partial<Record<SchedulingActorType, readonly ScheduleCandidate[]>>;
+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<SchedulingActorType, readonly ActorRequirement[]>>;
 
 export declare function addDays(date: Date, days: number): Date;
 
 /**
- * Chooses the actors an appointment is held on, for one actor type.
+ * 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 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 {
     readonly actorType: BookableActorType;
     /** The service being booked. Nothing is offered until it resolves. */
@@ -65,19 +111,25 @@ 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. */
-export declare interface AppointmentBooking {
-    readonly appointment: WithId<Appointment>;
-    /** The times reserved for it, one per schedule it is held on. */
-    readonly slots: readonly WithId<Slot>[];
-}
+export declare type AppointmentBooking = AppointmentWrite;
 
 /**
  * The booking form, writing the booking itself.
  *
- * Wraps {@link AppointmentProposalForm}: posts `Appointment/$book`, announces the
+ * Wraps {@link AppointmentProposalForm}: writes the booking, announces the
  * appointment and every time it reserved so views reading them refresh, then
  * reports what was written through `onBooked` — the only required prop.
  *
@@ -88,7 +140,7 @@ export declare interface AppointmentBooking {
  */
 export declare function AppointmentBookingForm(props: AppointmentBookingFormProps): JSX.Element;
 
-export declare interface AppointmentBookingFormProps extends Omit<AppointmentProposalFormProps, 'onBook'> {
+export declare interface AppointmentBookingFormProps extends Omit<AppointmentProposalFormProps, 'onSubmit' | 'mode' | 'ignoreAppointment'> {
     /**
      * Called with what the booking wrote.
      *
@@ -147,19 +199,13 @@ 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.
+ * hands the proposal out to be written.
  *
- * 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
+ * Writes nothing and announces nothing: `onSubmit` 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
- * one that books.
+ * one that books, and {@link AppointmentRescheduleForm} the one that moves a visit
+ * already on file.
  *
  * @param props - The React props.
  * @returns The form.
@@ -167,6 +213,8 @@ export declare interface AppointmentOptionRowProps {
 export declare function AppointmentProposalForm(props: AppointmentProposalFormProps): JSX.Element;
 
 export declare interface AppointmentProposalFormProps {
+    /** What the proposal is for. Defaults to booking a new visit. */
+    readonly mode?: AppointmentProposalMode;
     /** Pre-fills where the visit is, for a host that already knows. */
     readonly defaultLocation?: WithId<Location_2>;
     /** Pre-fills the visit type, for a deep link or a reschedule. */
@@ -174,9 +222,23 @@ export declare interface AppointmentProposalFormProps {
     /** Pre-fills who the visit is for, for a host launching from a patient's chart. */
     readonly defaultPatient?: WithId<Patient>;
     /**
-     * The day the time search opens on. Defaults to today.
+     * Pre-fills who and what the visit is held on, for a host that already knows — the
+     * actors an appointment being moved is currently held on, say.
+     *
+     * Read once, at mount: the fields own what they are asked for afterwards.
+     */
+    readonly defaultSelections?: ActorSelections;
+    /**
+     * An appointment whose own times are not to count as taken.
      *
-     * A day, not a time: only a time `$find` offered can be chosen.
+     * For a form searching on behalf of an appointment that already exists: without it,
+     * the time it holds blocks every search that keeps any of the actors holding it, and
+     * moving a visit to a different room at the same hour finds nothing.
+     */
+    readonly ignoreAppointment?: Reference<Appointment> | WithId<Appointment>;
+    /**
+     * The day the time search opens on, and the day a typed time starts out on.
+     * Defaults to today.
      */
     readonly defaultStart?: Date;
     /**
@@ -209,12 +271,78 @@ export declare interface AppointmentProposalFormProps {
     /** 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.
+     * Writes the proposal the form assembled.
+     *
+     * Resolving marks the form written, so it stops offering to write until an answer
+     * changes; rejecting shows the reason as the write's refusal, every answer kept.
      *
-     * Resolving marks the form booked, so it stops offering to book until an answer
-     * changes; rejecting shows the reason as the booking's refusal, every answer kept.
+     * In `book` mode the proposal carries the patient and the visit type's required
+     * codes; in `reschedule` mode it is the time as `$find` offered it, untouched.
+     */
+    readonly onSubmit: (proposal: Appointment, options: BookOptions) => void | Promise<void>;
+    /** Extensions to put on every appointment this form books. */
+    readonly appointmentExtensions?: readonly Extension[];
+    /**
+     * Allows for manual entry of a time and length, bypassing the `$find` search and
+     * `$book` endpoint.
      */
-    readonly onBook: (proposal: Appointment) => void | Promise<void>;
+    readonly canBypassSchedulingRules?: boolean;
+}
+
+/**
+ * What the proposal the form assembles is for, which decides what it asks for.
+ *
+ * `book` gathers everything a new visit is written with: who it is for, and whatever
+ * its visit type requires. `reschedule` gathers only what decides the time, because
+ * `Appointment/[id]/$reschedule` moves a visit already on file and writes nothing else
+ * about it — asking for details it would drop is asking for them under false pretences.
+ *
+ * The visit type goes the same way: in `reschedule` mode a `defaultService` is shown
+ * rather than asked for, since the operation is measured against it but will not change
+ * it. Without one it is still asked, because the search cannot run without a visit type.
+ */
+export declare type AppointmentProposalMode = 'book' | 'reschedule';
+
+/** What a reschedule wrote, as `Appointment/[id]/$reschedule` returned it. */
+export declare type AppointmentReschedule = AppointmentWrite;
+
+/**
+ * The form that moves a visit already on file, to another time or another set of actors.
+ *
+ * Wraps {@link AppointmentProposalForm}, opened on what the appointment is held on now
+ * and searching as though it were not: the time it occupies is the time it is being
+ * moved off, so `$find` is told to ignore it, which is what lets the same hour in a
+ * different room be found.
+ *
+ * Posts `Appointment/[id]/$reschedule`, announces the appointment, the times it gave up
+ * and the times it took, so views reading them refresh, then reports what was written
+ * through `onRescheduled`.
+ *
+ * Only the time and the actors are asked for. Everything else on the appointment — who
+ * it is for, its status, its visit type, whatever clinical detail it carries — is left
+ * exactly as it was, because that is all the operation will write. The visit type is
+ * shown rather than offered: `$reschedule` takes none, reading the one the appointment
+ * is on file for instead, since changing what a visit *is* would leave its required
+ * codes, its authorization, and anything applied at booking keyed to a type it no
+ * longer has.
+ *
+ * @param props - The React props.
+ * @returns The form.
+ */
+export declare function AppointmentRescheduleForm(props: AppointmentRescheduleFormProps): JSX.Element;
+
+export declare interface AppointmentRescheduleFormProps extends Omit<AppointmentProposalFormProps, 'onSubmit' | 'mode' | 'defaultService' | 'defaultSelections' | 'defaultPatient' | 'ignoreAppointment' | 'mrnSystem' | 'procedureBinding' | 'diagnosisBinding' | 'canBypassSchedulingRules' | 'appointmentExtensions'> {
+    /** The appointment being moved. */
+    readonly appointment: WithId<Appointment>;
+    /**
+     * Called with what the move wrote.
+     *
+     * The answers stay on screen and the form stops offering to move until one of them
+     * changes, so a host can keep this mounted without it writing twice. A failure here
+     * is logged rather than shown as a refusal: the appointment has already moved by the
+     * time it runs.
+     */
+    readonly onRescheduled: (reschedule: AppointmentReschedule) => void | Promise<void>;
 }
 
 /**
@@ -238,6 +366,8 @@ export declare interface AppointmentServiceSelectProps {
     /** A chosen site, which narrows the services on offer to the ones held there. */
     readonly location?: WithId<Location_2> | Reference<Location_2>;
     readonly label?: string;
+    readonly placeholder?: string;
+    readonly required?: boolean;
     readonly error?: string;
     readonly disabled?: boolean;
 }
@@ -246,7 +376,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[];
@@ -270,13 +400,22 @@ export declare interface AppointmentSlotGroupCardProps {
     readonly disabled?: boolean;
 }
 
+/** What a scheduling operation wrote: the appointment, and the times it holds. */
+export declare interface AppointmentWrite {
+    readonly appointment: WithId<Appointment>;
+    /** The times reserved for it, one set per schedule it is held on. */
+    readonly slots: readonly WithId<Slot>[];
+}
+
 /**
  * Actor types whose schedules may be offered for booking, in the order they are
  * asked about.
  *
- * Each type becomes one 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.
+ * 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`,
@@ -297,6 +436,12 @@ export declare interface BookingRequirementValues {
     readonly medicalNecessity: boolean;
 }
 
+/** What `onBook` is told about the proposal it was handed. */
+export declare interface BookOptions {
+    /** True when the time was typed (& unvalidated) rather than chosen from the search. */
+    readonly manual: boolean;
+}
+
 export declare function Calendar(props: CalendarProps): JSX.Element;
 
 export declare interface CalendarProps {
@@ -325,6 +470,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;
@@ -426,11 +591,17 @@ export declare interface FormatZonedTimeOptions {
  * 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[];
 
@@ -449,16 +620,16 @@ export declare function getActorGroupKey(appointment: Appointment): string;
 export declare function getActorsKey(actors: readonly Reference[]): string;
 
 /**
- * Extracts the resource type from a reference to an actor.
+ * Extracts the resource type of an actor, given as itself or as a reference.
  *
  * 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 reference - A Reference to a schedulable resource
- * @returns The type that the reference refers to.
+ * @param actor - A schedulable resource, or a Reference to one
+ * @returns The type of the actor.
  */
-export declare function getActorType(reference: SchedulingActor): SchedulingActorType;
+export declare function getActorType(actor: SchedulingActorValue): SchedulingActorType;
 
 /**
  * Provides the label we use for scheduling resource types in this UI
@@ -468,6 +639,14 @@ export declare function getActorType(reference: SchedulingActor): SchedulingActo
  */
 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.
  *
@@ -547,28 +726,51 @@ export declare function getFindWindowError(range: DateRange): string | undefined
 /**
  * Returns the input type to use for a date or time field.
  *
- * JSDOM does not fire change events for `<input type="date">` or
- * `<input type="time">`, so tests get a plain text field, matching what
+ * JSDOM does not fire change events for `<input type="date">`, `<input type="time">`
+ * or `<input type="datetime-local">`, so tests get a plain text field, matching what
  * `DateTimeInput` does.
  *
  * @param type - The native input type to use outside of tests.
  * @returns The input type for the current environment.
  */
-export declare function getNativeInputType(type: 'date' | 'time'): string;
+export declare function getNativeInputType(type: 'date' | 'time' | 'datetime-local'): string;
+
+/**
+ * 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 getRequirements(selections: ActorSelections): ActorRequirement[];
+
+/**
+ * Flattens the loaded actor resources into a map, keyed by their reference.
+ * @param selections - What has been chosen.
+ * @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 actor types
+ * Returns everything chosen, across rows and actor types.
  * @param selections - What has been chosen.
- * @returns The chosen candidates in `BOOKABLE_ACTOR_TYPES` order
+ * @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): string | undefined;
+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 getUnsatisfiableRows(selections: ActorSelections): UnsatisfiableRows | undefined;
 
 /**
  * Search window for a calendar day in the given timezone, starting from now if that day is already underway.
@@ -587,9 +789,11 @@ export declare function getZonedDayRange(day: Date, timezone?: string): Required
  * @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[];
 
 /**
  * Whether every requirement a visit type names has been answered.
@@ -624,6 +828,15 @@ export declare function isRequirementAnswered(requirement: SchedulingRequirement
  */
 export declare function isViewerTimezone(timezone: string | undefined, viewer?: string): boolean;
 
+/**
+ * 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
  * rejected outright, so callers have to keep their own date range inside it.
@@ -670,6 +883,14 @@ export declare interface MultiCalendarSource {
  */
 export declare function parseDayKey(key: string): Date;
 
+/**
+ * Reads a native datetime input's value as an instant in a timezone.
+ * @param value - A `YYYY-MM-DDTHH:MM` value, as the input reports it.
+ * @param timezone - IANA timezone identifier. Defaults to the browser's.
+ * @returns The instant, or undefined while the value is not a complete date and time.
+ */
+export declare function parseZonedDateTimeInput(value: string, timezone?: string): Date | undefined;
+
 /**
  * Reads a wall-clock time on a given day as an instant in a timezone.
  *
@@ -680,6 +901,18 @@ export declare function parseDayKey(key: string): Date;
  */
 export declare function parseZonedTime(day: Date, time: string, timezone?: string): Date | undefined;
 
+/**
+ * Reads what a scheduling operation wrote out of the bundle it answers with.
+ *
+ * `$book` and `$reschedule` both answer with the appointment and every Slot they
+ * created, in one transaction bundle.
+ *
+ * @param written - The bundle the operation returned.
+ * @param operation - What was called, for the error a bundle without an appointment raises.
+ * @returns The appointment and the times reserved for it.
+ */
+export declare function readAppointmentWrite(written: Bundle<WithId<Appointment> | WithId<Slot>>, operation: string): AppointmentWrite;
+
 /**
  * Actor types that must be chosen before a search can run.
  *
@@ -688,6 +921,35 @@ export declare function parseZonedTime(day: Date, time: string, timezone?: strin
  */
 export declare const REQUIRED_ACTOR_TYPES: ReadonlySet<SchedulingActorType>;
 
+export declare interface RescheduleDefaults {
+    /** The visit type the appointment is on file under, where it records one. */
+    readonly service: WithId<HealthcareService> | undefined;
+    /** Who and what it is held on now, arranged into the rows a form asks for them in. */
+    readonly selections: ActorSelections;
+    /**
+     * Actors the visit is held on whose schedules cannot be offered back, named where they
+     * could be read.
+     *
+     * A Schedule that is inactive, no longer names the visit type, or is held on an actor
+     * this form does not book leaves its actors out of the rows above — and a move writes
+     * the actors it is given, so these are about to be dropped off the visit.
+     */
+    readonly droppedActors: readonly SchedulingActor[];
+    /**
+     * Set when the visit type, or a Slot or Schedule the visit is held on, could not be read.
+     *
+     * `$reschedule` reads those same references, so no move from here would be accepted.
+     */
+    readonly error: unknown;
+    /**
+     * True until the reads settle.
+     *
+     * A form reads its defaults once, at mount, so one mounted while this is true would
+     * open on nothing and never take them.
+     */
+    readonly loading: boolean;
+}
+
 /**
  * Edits weekly availability for one visit service type, either as a Schedule's
  * override of the service hours or as the service's own default hours.
@@ -713,7 +975,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;
 }
 
 /**
@@ -734,7 +996,15 @@ export declare interface ScheduleOverrideEditorProps extends CommonProps {
  */
 export declare type SchedulingActor = Schedule['actor'][number];
 
-export declare type SchedulingActorType = Dereference<SchedulingActor>['resourceType'];
+/** A loaded actor resource. */
+export declare type SchedulingActorResource = WithId<Dereference<SchedulingActor>>;
+
+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}.
@@ -746,9 +1016,9 @@ export declare type SchedulingActorType = Dereference<SchedulingActor>['resource
  *   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.
+ * - Shows what is booked: clicking an appointment opens {@link AppointmentDetails} in the
+ *   same pane the booking form uses, describing the visit and offering to cancel or
+ *   reschedule it.
  * - 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
@@ -767,11 +1037,32 @@ export declare interface SchedulingWorkspaceProps {
     readonly diagnosisBinding?: string;
     readonly onBooked?: (booking: AppointmentBooking) => void | Promise<void>;
     readonly onCancelled?: (appointment: WithId<Appointment>) => void | Promise<void>;
+    readonly onRescheduled?: (reschedule: AppointmentReschedule) => 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;
+    /**
+     * Lets the booking form take a typed time and length, placing a visit the scheduling
+     * rules would refuse: over occupied or blocked time, past the configured capacity,
+     * or at a time or length the visit type does not offer.
+     *
+     * Passing it draws the fields; it enforces nothing. Which users get it is the host
+     * application's responsibility.
+     *
+     * Such a booking is sent as a transaction, so the appointment and its Slots commit
+     * together on projects with the `transaction-bundles` feature enabled. Without it they
+     * are applied as a plain batch, where an appointment that failed to write would leave
+     * Slots holding no visit.
+     * @see https://www.medplum.com/docs/fhir-datastore/fhir-batch-requests#batches-vs-transactions
+     */
+    readonly canBypassSchedulingRules?: boolean;
+    /**
+     * Extensions to put on every appointment booked from this workspace. See
+     * {@link AppointmentProposalFormProps.appointmentExtensions}.
+     */
+    readonly appointmentExtensions?: readonly Extension[];
 }
 
 /**
@@ -801,6 +1092,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.
@@ -816,10 +1121,10 @@ export declare interface ServiceDefaultEditorProps extends CommonProps {
 /**
  * Immutably gives a Schedule its own hours for a HealthcareService, in place of the service default.
  * Reads back through `getEffectiveAvailability`; to drop the calendar back to the default, clear the
- * parameter with `clearScheduleParameter(schedule, service, 'availability')` from `@medplum/core`.
+ * parameter with `clearScheduleSchedulingParameter(schedule, service, 'availability')` from `@medplum/core`.
  *
  * Availability is the one parameter with a typed wrapper, because it is the only one that is not a single
- * `value[x]`: `bufferBefore` and the rest go through `setScheduleParameter` directly, already legible as
+ * `value[x]`: `bufferBefore` and the rest go through `setScheduleSchedulingParameter` directly, already legible as
  * `{ url: 'bufferBefore', valueDuration: { value: 10, unit: 'min' } }`. Availability is a repeating nested
  * structure, so hand-building it at every call site would mean re-deriving the encoding.
  *
@@ -852,6 +1157,16 @@ export declare type TimeOfDay = 'any' | 'morning' | 'afternoon';
  */
 export declare function toCodings(elements: readonly ValueSetExpansionContains[]): Coding[];
 
+export declare function toScheduleCandidate(schedule: WithId<Schedule>, service: WithId<HealthcareService> | undefined, actors: Map<string, SchedulingActorResource>): ScheduleCandidate | undefined;
+
+/** 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.
  *
@@ -872,6 +1187,14 @@ export declare interface UseProposedAppointmentsOptions {
     readonly range: DateRange;
     /** Times to ask for per combination. Defaults to 20. */
     readonly count?: number;
+    /**
+     * An appointment whose own times are not to count as taken.
+     *
+     * For searching on behalf of an appointment that already exists: the times it holds
+     * are the times it is being moved off, and left standing they would block every
+     * search that keeps any of the actors it is held on.
+     */
+    readonly ignoreAppointment?: Reference<Appointment> | WithId<Appointment>;
 }
 
 export declare interface UseProposedAppointmentsResult {
@@ -888,6 +1211,23 @@ export declare interface UseProposedAppointmentsResult {
     readonly windowError: string | undefined;
 }
 
+/**
+ * Reads what an appointment is currently held on, for a form that offers to move it.
+ *
+ * The visit type comes off `Appointment.serviceType`, which carries a reference to the
+ * HealthcareService it was booked under; the actors come off the Slots it holds, which
+ * name the Schedules — the appointment's own participants would not say which of an
+ * actor's schedules is the one being moved off.
+ *
+ * An actor that cannot be read keeps its schedule, shown under the name the schedule
+ * gives it: the move is written against the schedule, not the actor.
+ *
+ * @param appointment - The appointment being moved.
+ * @returns Its visit type and actors, whether they are still being read, who a move
+ * would drop off it, and why it could not be read, where it could not.
+ */
+export declare function useRescheduleDefaults(appointment: WithId<Appointment>): RescheduleDefaults;
+
 /**
  * Loads the Appointments for a set of schedules within a date range and keeps them live.
  *