@medalsocial/booking 0.0.0-placeholder.0 → 0.2.0

package/dist/core/machine.d.mts

@@ -0,0 +1,645 @@
+import { BookingConfig } from "./config.mjs";
+//#region src/core/machine.d.ts
+/**
+ * The three steps the design draws, and the three the machine holds.
+ *
+ * `when` is one screen and two questions — the stylist and the hour — because
+ * that is what a parent answers in one breath and what the frames show as
+ * «Frisør og tid». They were separate steps until the redesign, and the pair of
+ * them cost a parent a whole extra «Neste» to say a thing they had already
+ * decided.
+ *
+ * There is no `login` step, and there was one. It sat between the hour and
+ * «Bekreft» and asked who the parent was — Vipps, an e-mail code, or neither —
+ * at the one moment a walk-in parent least wants a decision. The login is an
+ * offer in a sheet now (the login sheet), opened from a row
+ * on `service` and `details`, and the machine knows nothing about it: a login
+ * changes who the contact fields are filled from, never which step is next.
+ */
+export type WizardStep = 'who' | 'service' | 'when' | 'details';
+/**
+ * «Hvem skal klippes?» — step 1's answer (SP10), one entry per chair.
+ *
+ * The wizard used to learn who a haircut was for last, in two text fields on
+ * «Bekreft», and a logged-in parent's children were a row of name chips there.
+ * Asking first is what lets everything after it be ABOUT the child: step 2
+ * offers «Samme som sist» for Theo, the ages that filter the menu are Theo's
+ * on the appointment day, and the booking goes to Medal as Theo's person id
+ * rather than a name a parent typed.
+ *
+ * `key` identifies the chair across edits and is never shown: `p:<id>` for a
+ * saved child, `self` for the logged-in parent, `adult` for a guest adult,
+ * `guest:<n>` for a guest's n-th child. Everything else is optional and ABSENT
+ * rather than blank, the rule the line items follow — a guest child has no
+ * name until «Bekreft» asks for one.
+ */
+export interface WizardPerson {
+  key: string;
+  /** A grown-up: no child fields on «Bekreft», the full menu on step 2. */
+  adult?: boolean;
+  /** Medal's id for a saved child — what `booked_for_person_id` carries. */
+  personId?: string;
+  name?: string;
+  birthYear?: number;
+  /** 1–12, when the parent gave one. */
+  birthMonth?: number;
+}
+/** The logged-in parent themselves, on step 1's «Meg selv (voksen)». */
+export declare const SELF_KEY = "self";
+/**
+ * A seat only a GUEST's step 1 can draw: a count chip's `guest:n`, a child
+ * named in the guest sheet (`new:…`), the «Voksen» chip's `adult`. A parent's
+ * step 1 draws cards for saved children and «Meg selv» and nothing else — so
+ * one of these under a family is a seat nobody can see or untick, counting
+ * towards the three.
+ */
+export declare function isGuestSeat(person: WizardPerson): boolean;
+export interface WizardService {
+  id: string;
+  name: string;
+  category: string;
+  durationMinutes: number;
+  priceOre: number;
+  maxPerBooking: number;
+  /** Drives step 3's weekend note and the surcharged price shown on the chip. */
+  weekendSurchargePct: number;
+  /**
+   * The salon's prep and cleanup time around this service, in minutes.
+   *
+   * Carried because a FAMILY needs them: two children seated back to back on
+   * one stylist are separated by the first one's cleanup plus the second one's
+   * prep, and `itemStartTimes` cannot honour a gap it does not know about.
+   * Availability is asked per service and each opening is judged on its own, so
+   * both instants can come back free while the engine refuses the combined
+   * submission — a visit offered to the parent and then rejected.
+   *
+   * Zero is the ordinary value and the wire's own default.
+   */
+  bufferBeforeMinutes: number;
+  bufferAfterMinutes: number;
+  /**
+   * Who the service is for, in whole years, inclusive (SP10) — «Barnehageklipp»
+   * up to 6, say. Used to SUGGEST, never to refuse: Medal does not reject a
+   * booking on age, and a parent may know better. Absent is «any age».
+   */
+  ageMinYears?: number;
+  ageMaxYears?: number;
+}
+export interface WizardItem {
+  /** The person's FIRST service. */
+  service: WizardService;
+  /**
+   * The person's further services, performed back to back after `service` as
+   * ONE visit. Absent means one service — never `[]`.
+   */
+  extraServices?: WizardService[];
+  /** The child this line is for. Asked inline in step 4. */
+  bookedForName?: string;
+  /** Optional fødselsår — powers "Jonas (9)" in the CRM later. */
+  bookedForBirthYear?: number;
+  /**
+   * The saved child this line is for (SP10) — sent as `booked_for_person_id`
+   * when the phone rule allows it (see the create route). Never typed: it
+   * comes only from a child card on step 1.
+   */
+  bookedForPersonId?: string;
+  /** The child's birth month, for the age on the appointment day. */
+  bookedForBirthMonth?: number;
+  /** A grown-up's line: «Bekreft» asks nothing about a child for it. */
+  adult?: boolean;
+}
+export interface WizardState {
+  step: WizardStep;
+  /**
+   * Who is coming — step 1's answer. One entry per chair, in the order the
+   * line items follow: `items[i]` is `people[i]`'s haircut once every chair
+   * has a service.
+   */
+  people: WizardPerson[];
+  /**
+   * Step 2's answers so far, one per person — `null` where that person has no
+   * service yet. `items` is built from these and `people` only once none is
+   * `null`, so a family half-way through step 2 has no basket and step 3
+   * stays shut.
+   */
+  choices: Array<WizardService | null>;
+  /**
+   * Each person's FURTHER services, parallel to `people` and `choices` —
+   * `extras[i]` is what `people[i]` has after `choices[i]`, performed back to
+   * back as one visit. `[]` is one service, and so is a person whose `choices`
+   * entry is still `null`: an extra never stands without a first service.
+   *
+   * A second array rather than turning `choices` into lists, because meda keeps
+   * its own copy of this state's shape and reads `choices` and `item.service`
+   * as single services — the multi-service visit is additive, and a screen that
+   * has never heard of it keeps working on the first service.
+   */
+  extras: WizardService[][];
+  items: WizardItem[];
+  /** null = «Første ledige» — the default, and the utilisation-maximising one. */
+  resourceId: string | null;
+  /**
+   * Whether the stylist question has been ANSWERED, as against left at its
+   * default.
+   *
+   * `resourceId` cannot say. `null` is «Første ledige», which is both the value
+   * a fresh wizard starts on and a real choice a parent makes by tapping «Alle»
+   * — and while the stylist and the hour were separate steps the difference was
+   * legible in `step` alone: a visitor who had answered was on `time`. One
+   * screen for both questions took that away, and the thing that noticed is
+   * `applyPrefill`, whose whole contract is «fills blanks, never overwrites»:
+   * without this a «Bestill igjen» link naming Sara would land on a parent who
+   * had just tapped «Alle» and quietly replace their answer.
+   *
+   * Set by `pickResource` either way, and by the parallel `setPartyMode` — «two
+   * stylists at once» is an answer about who cuts the hair even though it
+   * clears the preference. Cleared whenever the preference itself is cleared
+   * for a reason the parent did not choose: a replaced basket, or a sibling the
+   * named stylist cannot take.
+   */
+  stylistAnswered: boolean;
+  partyMode: 'sequential' | 'parallel';
+  startTs: number | null;
+  resolvedResourceId: string | null;
+  /**
+   * The stylist each line resolved to, in basket order — the half of a party
+   * slot that `resolvedResourceId` cannot hold.
+   *
+   * `null` for everything except a party slot chosen on step 3, where
+   * `resolvedResourceId` still answers for the whole visit. Non-null it is one
+   * id per line item, and it is what a parallel party actually needs: two
+   * children seen at the same instant are seen by two *different* stylists, so
+   * there is no single id that describes the visit.
+   *
+   * Read through `itemResourceIds` rather than directly, so the submission and
+   * the confirmation card cannot disagree about who is cutting whose hair.
+   */
+  partyResourceIds: string[] | null;
+  contact: {
+    phone: string;
+    name: string;
+    email: string;
+  };
+  notes: string;
+  consentTerms: boolean;
+  consentMarketing: boolean;
+  /**
+   * A code, never a sentence. The Norwegian copy for each case belongs to the
+   * component that shows it, so the same rule can be a toast in one place and
+   * inline text in another without this file knowing either.
+   *
+   * Wider than what `reduce` can currently produce, on purpose. The submit route
+   * answers with `conflict`, `invalidInput`, `unconfigured` and `upstreamError`
+   * as well as `slotTaken`, and those have to land somewhere. Somewhere is here:
+   * if the union only admitted what this file raises, the details step would grow
+   * a second error slot of its own and the sticky bar and the form would start
+   * disagreeing about whether anything is wrong.
+   *
+   * `upstreamError` is the create route's 502 — Medal answered something this
+   * site has no mapping for, or did not answer at all. It is an outage rather
+   * than a mistake the visitor made, but it arrives with them waiting on a
+   * button they have just pressed, so it needs a sentence of its own rather
+   * than being folded into `conflict` — which says «prøv en gang til», and
+   * trying again is exactly what will not help here.
+   */
+  /**
+   * A service a link named for a parent whose family is known, held until
+   * step 1 says who it is for (`holdService`). Each person seated after that
+   * starts on it where it suits them — a kids' service for a child, anything
+   * else for a grown-up — instead of a guest chair being invented for it.
+   */
+  pendingService: WizardService | null;
+  error: 'maxParty' |
+  /**
+   * One person asked for more services than `party.maxServicesPerPerson`
+   * allows — `toggleServiceFor` refusing the next one. A code like the rest:
+   * the sentence (and the number in it) belongs to whoever shows it.
+   */
+  'maxServices' | 'slotTaken' | 'conflict' | 'invalidInput' | 'unconfigured' | 'upstreamError' |
+  /**
+   * The create route's 409 for a submission Medal already holds under its
+   * key: it may well be booked, so the parent is sent to their e-mail
+   * rather than to the button.
+   */
+  'inProgress' | null;
+}
+export type WizardAction =
+/**
+ * Back to an empty wizard, for «Bestill ny time» on the confirmation.
+ *
+ * A parent who has just booked one child and needs a SEPARATE appointment —
+ * another service whose `maxPerBooking` is 1, or a sibling who wants a
+ * different hour — has to be able to start over. The confirmation is now
+ * restored across a reload, so without this the only ways out of it are
+ * closing the tab or waiting for the stored attempt to age out.
+ */
+{
+  type: 'startOver';
+} |
+/**
+ * Step 1's answer: who is coming. Replaces the party; a person who stays
+ * (the same `key`) keeps the service already chosen for them, so going back
+ * to add a sibling does not re-ask the first child. `advance` moves on to
+ * step 2 — a guest's «2 barn» chip is one tap, a logged-in parent ticks
+ * children and presses «Neste».
+ */
+{
+  type: 'choosePeople';
+  people: WizardPerson[];
+  advance?: boolean;
+  /**
+   * «Samme som sist»: a service to start each person NEW to the party on,
+   * aligned with `people` — the child's last haircut, where the shell
+   * knows one. A person already in the party keeps their own answer.
+   */
+  services?: ReadonlyArray<WizardService | null>;
+} |
+/**
+ * Step 2's answer for ONE person. For a party of one it is the old one-tap
+ * `pickService` and moves on; for a family it fills that child's line and
+ * waits for the rest. `resourceServiceIds` is `addService`'s: what the named
+ * stylist can do, so a service they cannot do releases the preference.
+ */
+{
+  type: 'pickServiceFor';
+  index: number;
+  service: WizardService;
+  resourceServiceIds?: readonly string[];
+} |
+/**
+ * The multi-select service card: a person's list gains the service, or loses
+ * it if it was already there. The first service a person gets is their
+ * `choices` entry, every later one an extra; removing the first promotes the
+ * next, and removing the last leaves the person unanswered.
+ *
+ * Never moves the visitor — unlike the one-tap `pickServiceFor`, a person
+ * choosing several services is not done after the first, so «Neste» is theirs
+ * (the shell's `goToStep('when')`). Refused with `maxServices` past the
+ * site's per-person ceiling and with `maxParty` when more people would take
+ * the service than its `maxPerBooking`. `resourceServiceIds` is
+ * `pickServiceFor`'s: the named stylist has to do the person's whole list.
+ */
+{
+  type: 'toggleServiceFor';
+  index: number;
+  service: WizardService;
+  resourceServiceIds?: readonly string[];
+} | {
+  type: 'pickService';
+  service: WizardService;
+} |
+/**
+ * The parent's family has appeared (a login, a guardian read after the
+ * first render) or step 1 is shown again under it: the guest seats go —
+ * see `isGuestSeat` — and a guest «Voksen» becomes «Meg selv». Only while
+ * nothing is held on them (steps 1 and 2); from the hour on they are real
+ * chairs with a time, and «Bekreft» names them. A party emptied by it goes
+ * back to step 1, where the children are.
+ */
+{
+  type: 'seatFamily';
+} |
+/**
+ * One person joins the party as it is WHEN this lands — a child the parent
+ * just created in Medal, after the await. Refused at the limit, a no-op for
+ * somebody already seated.
+ */
+{
+  type: 'addPerson';
+  person: WizardPerson;
+} |
+/** A link's service, held for the people step 1 is about to seat — see `pendingService`. */
+{
+  type: 'holdService';
+  service: WizardService | null;
+} |
+/**
+ * A sibling, added on step 1 — and the one fact about the stylist catalogue
+ * this file is allowed to know.
+ *
+ * `resourceServiceIds` is what the currently preferred stylist can do. It
+ * rides on the action because the alternative was worse in both directions:
+ * the machine cannot fetch the catalogue, and a shell that cleared the
+ * preference itself would need an action that changes `resourceId` without
+ * moving the visitor off step 1, which `pickResource` is not.
+ *
+ * Absent is «the caller does not know», not «the stylist does nothing». A
+ * missing list keeps the preference, because silence is not evidence.
+ */
+{
+  type: 'addService';
+  service: WizardService;
+  resourceServiceIds?: readonly string[];
+} | {
+  type: 'pickResource';
+  resourceId: string | null;
+} | {
+  type: 'pickSlot';
+  startTs: number;
+  resourceId: string | null;
+} |
+/**
+ * How the party is seen — step 2's second question, and the one that decides
+ * which search step 3 runs.
+ *
+ * Its own action rather than a field on `pickResource`, because the two
+ * answers are independent: «Sara» and «rett etter hverandre» are one visit,
+ * and a parent who changes only the mode has not changed their mind about
+ * the stylist.
+ */
+{
+  type: 'setPartyMode';
+  mode: WizardState['partyMode'];
+} |
+/**
+ * A whole family seated in one tap: the instant the visit starts and the
+ * stylist each child got.
+ *
+ * Separate from `pickSlot` because a party slot answers a question
+ * `pickSlot` has no room for. `pickSlot` carries one resolved stylist, which
+ * is all a single booking ever has; a party in `parallel` has one per child
+ * and they are deliberately different people.
+ *
+ * `resourceIds` is one id per line item, in basket order — never null,
+ * because a slot that cannot name the two stylists cannot promise that two
+ * children are seen at once.
+ *
+ * `mode` travels with the slot rather than being read off the state, and it
+ * is what makes step 3's «men begge kan tas samtidig kl. 15:00» work: that
+ * offer appears while the machine still says `sequential`, and seating a
+ * parallel slot sequentially would submit the second child half an hour
+ * after a stylist who is free at the hour itself. Carrying it here also
+ * removes the ordering trap — `setPartyMode` clears the slot, so a caller
+ * that dispatched the two actions the other way round would throw away the
+ * time the parent had just accepted.
+ */
+{
+  type: 'pickPartySlot';
+  startTs: number;
+  resourceIds: string[];
+  mode: WizardState['partyMode'];
+} | {
+  type: 'slotTaken';
+} |
+/**
+ * A submission the create route refused, in the vocabulary `WizardState.error`
+ * already speaks.
+ *
+ * Without it the four codes below are a union nothing can produce: the route
+ * answers `conflict`, `invalidInput`, `unconfigured` and `upstreamError`, and
+ * step 4 has a Norwegian sentence for each, but there was no action that could
+ * put one into `state.error` — so the failure would have had to be held beside
+ * the machine, in a second error slot the machine's own clearing rules never
+ * touch.
+ *
+ * `slotTaken` and `maxParty` are excluded rather than admitted. Each already
+ * has an action that does more than raise a code — `slotTaken` drops the slot
+ * and sends the visitor back to step 3, `addService` refuses the child while
+ * leaving the ones already chosen alone — and a second spelling of either is
+ * how a stolen slot ends up raised without the slot being dropped.
+ */
+{
+  type: 'submitFailed';
+  error: Exclude<NonNullable<WizardState['error']>, 'slotTaken' | 'maxParty'>;
+} | {
+  type: 'goToStep';
+  step: WizardStep;
+} | {
+  type: 'setContact';
+  field: keyof WizardState['contact'];
+  value: string;
+} |
+/**
+ * The two answers about the child, written onto the line item they belong to.
+ *
+ * Indexed rather than keyed by service, because two children in one party can
+ * genuinely share a service and the index is the only thing that tells those
+ * rows apart — the same reason step 4 keys its fields on it.
+ *
+ * Split over the two fields rather than taking a `Partial<WizardItem>`, so a
+ * caller cannot reach through this action and overwrite `service`, which is
+ * step 1's answer and not step 4's to change.
+ */
+{
+  type: 'setItemField';
+  index: number;
+  field: 'bookedForName';
+  value: string;
+} |
+/** `null` is «cleared», which an emptied year input is and `undefined` would
+ * be ambiguous about — a patch that says nothing versus one that says nothing
+ * is there. */
+{
+  type: 'setItemField';
+  index: number;
+  field: 'bookedForBirthYear';
+  value: number | null;
+} |
+/** A saved child picked for a guest line on «Bekreft» (a family chip); `null` detaches. */
+{
+  type: 'setItemField';
+  index: number;
+  field: 'bookedForPersonId';
+  value: string | null;
+} | {
+  type: 'setNotes';
+  value: string;
+} |
+/** One action for both boxes rather than two near-identical ones: they are the
+ * same gesture, and the pair that must never be confused — a marketing opt-in
+ * standing in for terms — is harder to write by accident when the difference
+ * is a required discriminant. */
+{
+  type: 'setConsent';
+  which: 'terms' | 'marketing';
+  accepted: boolean;
+} |
+/**
+ * A «Bestill igjen» link, applied. The shell dispatches this rather than
+ * calling `applyPrefill` on the state it holds, because `useReducer` is the
+ * only writer of that state — see `applyPrefill` for the rules.
+ */
+{
+  type: 'prefill';
+  prefill: WizardPrefill;
+  catalogue: WizardCatalogue;
+};
+/**
+ * What a `/min-side` «Bestill igjen» link can carry into the wizard:
+ * `?service=<id>&stylist=<id>` off the query string, and the child's name
+ * from the tab's session store (`rebook-store.ts`) — never from the URL.
+ *
+ * Every field is optional AND nullable, because `URLSearchParams.get` answers
+ * `null` for a missing key and the shell should not have to translate that.
+ * An empty string means the same as absent.
+ */
+export interface WizardPrefill {
+  serviceId?: string | null;
+  /** An id, or — from a «Bestill hos Siv» link — a display name or its slug. */
+  resourceId?: string | null;
+  who?: string | null;
+  /**
+   * `?antall=`: how many children. Clamped to the service's `maxPerBooking`
+   * and only meaningful for a kids' service, where it pre-creates that many
+   * lines; ignored for anything else.
+   */
+  party?: number | null;
+}
+/**
+ * What a prefill is checked against — the services step 1 would let the visitor
+ * tap, and the stylists step 2 would show for them.
+ *
+ * The SHELL decides what goes in here, and that is the point: the machine has
+ * no `bookableOnline` and no fetched stylist list, so «this id is one the
+ * visitor could have chosen» is a fact only the caller can supply. An id absent
+ * from the catalogue is ignored, whatever the link said.
+ */
+export interface WizardCatalogue {
+  services: readonly WizardService[];
+  resources: ReadonlyArray<{
+    id: string;
+    name?: string;
+    serviceIds: readonly string[];
+  }>;
+}
+/**
+ * The engine's own bound on `booked_for_name` — `maxLength: 200` in the SDK's
+ * OpenAPI document. Step 4's input has no `maxLength`, so this is the one limit
+ * that exists, and a prefilled name is cut to it rather than being carried into
+ * a body the engine answers 400 to.
+ */
+export declare const BOOKED_FOR_NAME_MAX_LENGTH = 200;
+export declare function initialState(): WizardState;
+/** The guest child in chair `n` (1-based) — a chip on step 1, or a sibling a link added. */
+export declare function guestChild(n: number): WizardPerson;
+/**
+ * True when the visitor may leave the current step — and on `details`, when they
+ * may submit at all. Answers about `state.step` only, so a Neste button can be
+ * `disabled={!canAdvance(state)}` and nothing else.
+ */
+export declare function canAdvance(state: WizardState): boolean;
+/**
+ * True when a step may be jumped to directly — the predicate behind whether a
+ * progress dot is tappable, and the guard `goToStep` applies to itself.
+ *
+ * Bounded by what is *behind* the target, never the target itself: reaching
+ * `details` requires a service and a time, but obviously not the contact
+ * details you are going there to type. Going back is therefore always allowed,
+ * because nothing precedes `service` — which is the case that matters, since
+ * back is what the dots are mostly for.
+ */
+export declare function canGoToStep(state: WizardState, step: WizardStep): boolean;
+/**
+ * When each child in the party sits down.
+ *
+ * `sequential` is the report's default and the ordinary case — one stylist,
+ * «rett etter hverandre», so the second child starts when the first is
+ * finished. `parallel` is two stylists at once, and every line starts together.
+ *
+ * The engine takes a `start_ts` per line item rather than one for the visit, so
+ * somebody has to do this arithmetic, and it is a rule about the booking rather
+ * than about a screen. Step 4 submits with it and the confirmation card reads
+ * «15:00 Jonas / 15:30 Emma» off the same function, which is the only way those
+ * two can be made to agree.
+ *
+ * Task 9 owns the slot SEARCH for a party; this is only the seating of a slot
+ * already chosen.
+ */
+export declare function itemStartTimes(items: WizardItem[], startTs: number, partyMode: WizardState['partyMode']): number[];
+/**
+ * How long the family is in the salon — the number the summary bar quotes as
+ * «60 min totalt» and the length of the .ics entry.
+ *
+ * The two modes are two different visits: `sequential` is one chair used twice,
+ * so the minutes add up, while `parallel` is two chairs at once and the family
+ * leaves when the *longest* cut finishes. Quoting the sum for a parallel party
+ * would tell a parent to set aside an hour for a visit that takes half of one,
+ * which is the whole reason «To frisører samtidig» is worth offering.
+ *
+ * `Math.max` seeded with 0 rather than spread over the durations alone:
+ * `Math.max()` of nothing is `-Infinity`, and an empty basket is a visit of no
+ * length rather than a negative one.
+ */
+export declare function visitMinutes(items: WizardItem[], partyMode: WizardState['partyMode']): number;
+/**
+ * How much EARLIER a family has to start than a single first child would.
+ *
+ * The schedule endpoint is asked for the FIRST person's whole visit — their
+ * service plus its extras — so `lastStartTs` is «the last start that visit
+ * fits»: the last minute at which its prep, every service's minutes and its
+ * cleanup all land inside the day's window. A family needs its whole chain to
+ * fit, so its own last start is earlier by exactly the part of the chain that
+ * hangs off the end of the first person's whole busy span — everybody after
+ * them.
+ *
+ * NOT `visitMinutes - firstDuration`, which was the first attempt and is wrong
+ * in a way that only shows on a mixed basket: `visitMinutes` deliberately
+ * excludes the LAST child's cleanup — the family has left by then — so the
+ * subtraction silently keeps the FIRST child's cleanup in place of the last
+ * one's. Where the later service has the bigger `bufferAfterMinutes` the cutoff
+ * comes out too late, which is the error in the direction that matters: it says
+ * «Fullt» about an afternoon that is actually over.
+ *
+ * Sequential is the tail of the chain: every child after the first costs their
+ * prep, their duration and their cleanup, and the first child's own cleanup is
+ * already inside the number being adjusted. Parallel is one chair each, so what
+ * has to fit is the LONGEST busy span rather than the sum.
+ */
+export declare function visitTailMinutes(items: WizardItem[], partyMode: WizardState['partyMode']): number;
+/** When the family leaves. The same arithmetic as `visitMinutes`, which is why
+ * it is that function and not a second copy of it: an .ics that ended before
+ * `visitMinutes` said the visit did would tell a calendar the parent was free
+ * while a child was still in the chair. */
+export declare function visitEndTs(items: WizardItem[], startTs: number, partyMode: WizardState['partyMode']): number;
+/**
+ * Whether step 2 asks how the party is seen.
+ *
+ * One child is not a party, and «Samme frisør, rett etter hverandre» is not a
+ * choice when there is nobody to be after. The machine answers rather than the
+ * component so that the picker and the search cannot disagree about when a
+ * booking has become a family visit.
+ */
+export declare function showsPartyMode(state: WizardState): boolean;
+/**
+ * Who is cutting whose hair, one answer per line item.
+ *
+ * The single reader for both shapes the machine can be in: a party slot names a
+ * stylist per child, and everything else has one answer for the whole visit —
+ * including `null`, which is «Første ledige» still to be resolved by the engine.
+ *
+ * Step 4's submission and the confirmation card both read it, which is the only
+ * way «hos Marcus» on the card can be guaranteed to be the `resource_id` that
+ * was actually booked for that child.
+ */
+export declare function itemResourceIds(state: WizardState): Array<string | null>;
+export type WizardConfig = Pick<BookingConfig, 'party' | 'categories' | 'fallbackCategory' | 'timeZone' | 'locale' | 'currency' | 'dayparts' | 'labels'>;
+export interface Wizard {
+  /**
+   * The most chairs one visit can take (`party.maxPeople`). The business's own
+   * ceiling is per service (`maxPerBooking`), and step 2 still honours it; this
+   * is the ceiling of the question on step 1, before any service is known.
+   */
+  readonly maxPeople: number;
+  initialState: typeof initialState;
+  reduce(state: WizardState, action: WizardAction): WizardState;
+  applyPrefill(state: WizardState, prefill: WizardPrefill, catalogue: WizardCatalogue): WizardState;
+  canAdvance: typeof canAdvance;
+  canGoToStep: typeof canGoToStep;
+  itemPriceOre(service: WizardService, startTs: number | null): number;
+  /** One person's whole visit: every service priced on its own, then summed. */
+  visitItemPriceOre(item: WizardItem, startTs: number | null): number;
+  totalPriceOre(items: WizardItem[], startTs: number | null): number;
+  itemStartTimes: typeof itemStartTimes;
+  visitMinutes: typeof visitMinutes;
+  visitTailMinutes: typeof visitTailMinutes;
+  visitEndTs: typeof visitEndTs;
+  showsPartyMode: typeof showsPartyMode;
+  itemResourceIds: typeof itemResourceIds;
+  summaryLine(state: WizardState, resolveStylistName: (resourceId: string) => string | null, now?: number): string;
+  guestChild: typeof guestChild;
+  isGuestSeat: typeof isGuestSeat;
+}
+/** The machine for one site: its party ceiling, kids' categories, clock, currency and words. */
+export declare function createWizard(config: WizardConfig): Wizard;
+//#endregion
+//# sourceMappingURL=machine.d.mts.map