@v-office/website-headless 0.2.0 → 1.1.0

package/dist/index.d.mts

@@ -1,1361 +1,2800 @@
-import { BookingPaymentOption, BookingPaymentScheduleKind, GuestQuote, GuestQuoteResult, Locale, SearchSearchSort, SubmittableBookingPaymentOption, WebsiteSDKOptions, createWebsiteSDK } from "@v-office/website-sdk";
-//#region src/store/index.d.ts
+import { $ as describeOutcome, $i as RentalFlag, $n as fetchRentalFlags, $r as CardSource, $t as GuestBound, A as QueryShape, Ai as SdkMode, An as LngLat, Ar as SdkConfigForInput, At as quickFilterDefs, B as toSdkQuery, Bi as RentalDistance, Bn as resultCardSource, Br as RouteParams, Bt as SEARCH_PARAMS, C as SearchState, Ci as isIsoDay, Cn as SameSpotGroup, Cr as EnvRecord, Ct as ResolvedFilters, D as createSearchStore, Di as Locale, Dn as circleOffsets, Dr as HUB_ENDPOINTS, Dt as facetOptions, E as SearchStoreOptions, Ei as Backend, En as SameSpotOptions, Er as sdkConfigFromEnv, Et as activeFilters, F as externalSearchHref, Fi as WebsiteSdk, Fn as mapPoints, Fr as CardSourceExtras, Ft as writeSelection, G as sortFromSearch, Gi as parseCounts, Gn as PreviewStrategy, Gr as CardBadge, Gt as SearchQuery, H as SORT_URL_VALUE, Hi as distanceFact, Hn as shortReviewerName, Hr as routeHref, Ht as SearchParamAliases, I as handoverQuery, Ii as resolveSdk, In as ResultLinkOptions, Ir as cardSource, It as partyPairs, J as EmptyCause, Ji as BedRun, Jn as DEFAULT_FLAG_FILTERS, Jr as CardImage, Jt as searchHref, K as sortResults, Ki as parseDistances, Kn as descriptionPreview, Kr as CardContext, Kt as WriteSearchOptions, L as queryShape, Li as ADJACENT_BELOW_M, Ln as SearchResultItem, Lr as loadRentalFacts, Lt as readParty, M as SanitizedSearch, Mi as SdkSetup, Mn as MapPoint, Mr as VofficeEndpointTable, Mt as resolveFilters, N as SdkQueryOptions, Ni as SdkSource, Nn as PinLabelOptions, Nr as VofficeEndpoints, Nt as withoutFilter, O as ExternalSearchLink, Oi as STAGES, On as distanceMeters, Or as HubEndpointTable, Ot as measureFilters, P as SdkSearchQuery, Pi as Stage, Pn as hasMapPoints, Pr as sdkConfigFor, Pt as withoutFilters, Q as SearchedParts, Qi as RentalDetail, Qn as assignSlugs, Qr as CardRating, Qt as DEFAULT_GUEST_LIMITS, R as resultsQueryFlagScript, Ri as DistanceKind, Rn as catalogueResultItem, Rr as rentalFactsMap, Rt as FlexibleStay, S as SearchScopeKind, Si as formatIsoDate, Sn as PixelOffset, Sr as createSdk, St as ResolveFiltersOptions, T as SearchStore, Ti as todayIso, Tn as SameSpotMode, Tr as SdkEnvError, Tt as WhenEmpty, U as SortKey, Ui as isAdjacent, Un as splitReviewAuthor, Ur as AlternativePeriod, Ut as SearchParamKeys, V as DEFAULT_SORT_OPTIONS, Vi as WATER_KINDS, Vn as newestReviewsFirst, Vr as RouteTemplate, Vt as SearchContract, W as SortOptionState, Wi as isSpecEcho, Wn as DescriptionPreview, Wr as BadgeRule, Wt as SearchPeriod, X as Relaxation, Xi as DescriptionContent, Xn as LoadRentalCatalogueOptions, Xr as CardModelOptions, Xt as ChildAgeRange, Y as OutcomeInput, Yi as CatalogueRental, Yn as FetchRentalFlagsOptions, Yr as CardLiveField, Yt as writeSearch, Z as SearchOutcome, Zi as RentalAddress, Zn as RentalFlagsResult, Zr as CardPill, Zt as DEFAULT_CHILD_AGE, _ as FAVORITE_LEAVE_MS, _a as EnhancePart, _i as Glyph, _n as DEFAULT_FIT, _r as fetchSearchPage, _t as FilterGroupSpec, a as PlaceMarker, aa as ReviewCriterion, ai as RentalFactsMap, an as Party, ar as AmenityPreviewItem, at as OffersWindowSpec, b as SearchActions, ba as GateMarkers, bi as IsoMonth, bn as frameFor, br as SharedSdk, bt as FilterSpec, c as DEFAULT_CLUSTER, ca as PlainTextOptions, ci as toCardModel, cn as clampParty, cr as AdaptEvent, ct as findCampaignStart, d as ResultsMapController, da as StructuredDocumentOptions, di as Range, dn as stayKeyOf, dr as adaptRental, dt as offersWindowQuery, ea as RentalImage, ei as CardStatus, en as GuestBounds, er as loadRentalCatalogue, et as CampaignChip, f as ResultsMapOptions, fa as TextMarkup, fi as matches, fn as Listener, fr as RawSearchPage, ft as ActiveFilter, g as CampaignOf, ga as ENHANCE_PARTS, gi as GLYPHS, gn as createStore, gr as WalkSummary, gt as FilterEntry, h as createResultsMapController, ha as plainText, hi as parsePriceLabel, hn as WritableStore, hr as WalkOptions, ht as FilterDef, i as MapPlace, ia as RentalRoom, ii as RentalFacts, in as GuestOptions, ir as ALWAYS_EXCLUDED_CATEGORIES, it as OfferWindow, j as ResultHandoverOptions, ji as SdkOptions, jn as MapBounds, jr as VOFFICE_ENDPOINTS, jt as readSelection, k as ExternalSearchSource, ki as SdkConfig, kn as layoutSameSpot, kr as HubEndpoints, kt as minimumSteps, l as MapResultsSource, la as RichBlock, li as CardMatch, ln as guestBounds, lr as AdaptRentalOptions, lt as findOfferWindows, m as ResultsMapSurface, ma as parseTextBlocks, mi as formatPriceLabel, mn as Unsubscribe, mr as SearchPageRequest, mt as FacetOptionsOptions, n as RentalAddressModeError, na as RentalReview, ni as PillOptions, nn as GuestKind, nr as slugify, nt as FindCampaignStartOptions, o as mergePlaces, oa as ReviewSummary, oi as StayPrice, on as QuoteOccupancy, or as AmenityPreviewOptions, ot as campaignChips, p as ResultsMapState, pa as normalizeStructuredDocument, pi as PriceCents, pn as Store, pr as SEARCH_PAGE_SIZE, pt as FacetOption, q as toSdkSort, qi as AmenityGroup, qn as descriptionSummary, qr as CardFact, qt as readSearch, r as rentalAddressLine, ra as RentalReviews, ri as RentalCardModel, rn as GuestLimits, rr as HIDDEN_ROOM_ATTRIBUTES, rt as FindOfferWindowsOptions, s as ClusterOptions, sa as RoomKind, si as StayWindow, sn as agesComplete, sr as amenityPreview, st as campaignGroup, t as RentalAddressMode, ta as RentalPropertyInfo, ti as FactKind, tn as GuestCaps, tr as rankHighlights, tt as CampaignChipsInput, u as MapViewReport, ua as RichInline, ui as CardSignal, un as occupancyOf, ur as RentalContentError, ut as offerWindowHref, v as FavoritesPort, va as EnhanceParts, vi as GlyphList, vn as DefaultFit, vr as walkSearchPages, vt as FilterMeasurement, w as SearchStatus, wi as nightsBetween, wn as SameSpotLayout, wr as SDK_ENV, wt as SdkFilterDefinition, x as SearchScope, xi as addDays, xn as idsInView, xr as shareSdk, xt as ImplicitScope, y as HistoryPort, ya as GATE_MARKERS, yi as IsoDay, yn as FitOptions, yr as loadSharedSdk, yt as FilterSelection, z as sanitizeSearch, zi as RentalCounts, zn as compareUndatedSearchOrder, zr as withRentalFacts, zt as QueryPair } from "./index-CPMXjfFH.mjs";
+import { BookingPaymentOption, BookingPaymentScheduleKind, ContactSubmitInput, GuestQuote, GuestQuoteResult, SubmittableBookingPaymentOption } from "@v-office/website-sdk";
+import { BackendKind } from "@v-office/website-sdk/capabilities/search";
+//#region src/map/constants.d.ts
+/** OpenFreeMap "Bright": free for commercial use, no key, no rate limit, OSM data. A third-party
+ *  request (the visitor's IP reaches the tile host), which is why the map components load tiles
+ *  on click by default. A brand style is a JSON file the site hosts. */
+export declare const DEFAULT_MAP_STYLE_URL: "https://tiles.openfreemap.org/styles/bright";
+/** Pins closer than this are "the same spot": below it their pills overlap at every usable zoom,
+ *  and the feeds' distinct pins sit at least 18 m apart, so 12 m splits cleanly (measured). */
+export declare const SAME_SPOT_METERS: 12;
+/** The list's re-settle pulse after a guest map move that changed the in-view set. A perceived-
+ *  responsiveness transition (the re-filter itself is instant), NOT simulated latency. */
+export declare const RELOAD_FLASH_MS: 220;
+//#endregion
+//#region src/sdk/errors.d.ts
+/** A failed SDK call and its whole `cause` chain as indented JSON (stacks skipped). */
+type DescribeSdkError = (error: unknown) => string;
+/** `console.error` the description, tagged by the SDK operation ("search.search", "contact.submit",
+ *  "quote.selectInsurance"), never by the component: the console must answer which call the backend
+ *  refused. Logs the description alone, so a caller that also logs the raw error prints it once. */
+type LogSdkFailure = (scope: string, error: unknown) => void;
+/** See {@link DescribeSdkError}. */
+export declare const describeSdkError: DescribeSdkError;
+/** See {@link LogSdkFailure}. */
+export declare const logSdkFailure: LogSdkFailure;
+//#endregion
+//#region src/rental/images.d.ts
+/** One photo URL, WebP where the host serves it: imgproxy `@webp` (−35 % measured), dyn
+ *  `.webp` (−17 %). The v10 host already answers WebP; any other host passes unchanged. */
+type WebpUrl = (url: string) => string;
+/** A `srcset` ("url 320w, url 480w"), each candidate through `webpUrl`. */
+type WebpSrcset = (srcset: string) => string;
+/** An uncropped rendition of a v9 imgproxy floor plan (`rs:fill:W:H:x` → `rs:fit:2560:2560:0`:
+ *  the SDK crops every image to 3:2, which cuts the room labels off a plan), or undefined
+ *  when the URL has no `rs:fill` segment to rewrite. */
+type FloorplanUrl = (src: string) => string | undefined;
+/** See {@link WebpUrl}. */
+export declare const webpUrl: WebpUrl;
+/** See {@link WebpSrcset}. */
+export declare const webpSrcset: WebpSrcset;
+/** See {@link FloorplanUrl}. */
+export declare const floorplanUrl: FloorplanUrl;
+//#endregion
+//#region src/shared/text.d.ts
+/** A copy string whose `{token}`s are `K`: every one of them is filled, none is required. Only a type
+ *  (the property never exists), so any string is assignable and a table still serializes. */
+type Template<K extends string> = string & {
+  readonly __tokens?: K;
+};
+/** The tokens a string literal carries: every `{…}` in it. A literal brace pair in copy reads as a
+ *  token, as it does for `fillTemplate`. */
+type TokensOf<S extends string> = S extends `${string}{${infer T}}${infer R}` ? T | TokensOf<R> : never;
+/** The tokens a copy key accepts: `K` of a `Template<K>`, none of a plain string. */
+type TokensAccepted<V> = V extends {
+  readonly __tokens?: infer K;
+} ? Exclude<K, undefined> : never;
+/** `O` (a site's literal overrides of `T`) where every string carries only tokens its key accepts. A
+ *  string with another token becomes `S & { "{x} is not a token of this string": never }`, so the
+ *  compiler names the token. Recurses into arrays and into nested groups (`SharedCopyOverrides`). */
+type CheckedCopy<T, O> = { readonly [P in keyof O]: P extends keyof T ? CheckedValue<T[P], O[P]> : never; };
+type CheckedValue<V, S> = S extends string ? [Exclude<TokensOf<S>, TokensAccepted<V>>] extends [never] ? S : S & { readonly [M in `{${Exclude<TokensOf<S>, TokensAccepted<V>> & string}} is not a token of this string`]: never; } : S extends readonly unknown[] ? { readonly [I in keyof S]: CheckedValue<V extends readonly (infer E)[] ? E : never, S[I]>; } : S extends object ? CheckedCopy<NonNullable<V>, S> : S;
+/** A site's copy overrides of `T` (a component's `XCopy`, or `SharedCopyOverrides`), checked: an
+ *  unknown key, a wrong type and a token its key does not accept are compile errors. Curried, so `T`
+ *  is named and the literal inferred: `defineCopy<ShowcaseCopy>()({ moreCount: "Alle {count}" })`.
+ *  Returns the overrides unchanged. A prop takes them as they are; the helper only adds the check. */
+type DefineCopy = <T extends object>() => <const O extends Partial<T>>(copy: O & CheckedCopy<T, O>) => O;
+/** Replace `{name}` tokens with `values`; an unknown token stays visible ("{nights}"), so a missing
+ *  value is seen in review instead of rendering as an empty string. A `Template<K>` needs a value for
+ *  every token in `K` and takes no other; a plain `string` takes any values. */
+type FillTemplate = <K extends string>(template: Template<K>, values: Readonly<Record<K, string | number>>) => string;
+/** See {@link DefineCopy}. */
+export declare const defineCopy: DefineCopy;
+/** See {@link FillTemplate}. */
+export declare const fillTemplate: FillTemplate;
+//#endregion
+//#region src/shared/tracking.d.ts
+/** Where a page is opened from: the parts of `window.location` a share link is built of. */
+interface ShareLocation {
+  /** The page's path. */
+  readonly pathname: string;
+  /** The page's query, with its "?". */
+  readonly search: string;
+  /** The page's origin (or the canonical one). */
+  readonly origin: string;
+}
+/** Options of `shareUrl`. */
+interface ShareUrlOptions {
+  /** Canonical origin (the site's own domain). Default: `location.origin`. */
+  readonly origin?: string;
+  /** Extra parameters to drop beside the tracking ones. */
+  readonly strip?: readonly string[];
+}
+/** utm_*, mtm_*, pk_*, gad_*, gclid, gbraid, wbraid, dclid, fbclid, msclkid, mc_eid, ref, _gl. Not
+ *  global (no `lastIndex` state); its `source` is safe to inline into a `<head>` script. */
+export declare const TRACKING_PARAM_PATTERN: RegExp;
+/** True for a key of the list. */
+type IsTrackingParam = (key: string) => boolean;
+/** The query (with or without its leading "?") without tracking parameters, returned without "?"
+ *  ("" when nothing else remains). */
+type WithoutTracking = (search: string) => string;
+/** Canonical origin + path + query without tracking (and `strip`) parameters, no hash: the recipient
+ *  gets the real domain and the guest's selection (`start`, `end`, `adults`, …). */
+type ShareUrl = (location: ShareLocation, options?: ShareUrlOptions) => string;
+/** See {@link IsTrackingParam}. */
+export declare const isTrackingParam: IsTrackingParam;
+/** See {@link WithoutTracking}. */
+export declare const withoutTracking: WithoutTracking;
+/** See {@link ShareUrl}. */
+export declare const shareUrl: ShareUrl;
+//#endregion
+//#region src/shared/storage.d.ts
+/** The part of Web Storage this package uses. */
+interface StorageLike {
+  /** The value under `key`, or null. */
+  getItem(key: string): string | null;
+  /** Store `value` under `key` (may throw: quota, private mode). */
+  setItem(key: string, value: string): void;
+  /** Drop `key`. */
+  removeItem(key: string): void;
+}
+/** `localStorage`/`sessionStorage` when present and writable, else null (SSR, Safari private mode,
+ *  storage disabled, a sandboxed frame whose mere access throws). */
+type BrowserStorage = (kind: "local" | "session") => StorageLike | null;
+/** See {@link BrowserStorage}. */
+export declare const browserStorage: BrowserStorage;
+//#endregion
+//#region src/shared/types.d.ts
+/** A link a notice or a fact offers (a phone, a mail, an enquiry page). */
+interface ContactLink {
+  /** The visible text ("040 123 456", "Anfrage senden"). */
+  readonly label: string;
+  /** `tel:`, `mailto:` or a page. */
+  readonly href: string;
+}
+/** Not bookable online before `from` (an operator change, a new season). One object for SearchBar
+ *  (`dates.bookable`) and Quote (`bookable`), so the decision is one site constant (`BOOKABLE`). */
+interface BookableFrom {
+  /** First day bookable online. SearchBar floors its calendar, month strip and ± windows here; Quote
+   *  opens its calendar on this month and does NOT floor (the PMS availability stays the arbiter). */
+  readonly from: IsoDay;
+  /** The notice shows while today is before this day. Default `from`. A site whose notice ends on a
+   *  different day than the floor (an operator change on one date, online booking from a later one)
+   *  sets both. */
+  readonly noticeUntil?: IsoDay;
+  /** A phone or enquiry link rendered inside the notice (SearchBar date panel, Quote above its calendar). */
+  readonly contact?: ContactLink;
+  /** How the notice names `from`: the day (default), its month ("Januar 2027") or its year
+   *  ("2027"), for an opening announced as "ab 2027". Presentation only: the floor stays `from`. */
+  readonly precision?: "day" | "month" | "year";
+}
+//#endregion
+//#region src/countries/countries.d.ts
+/** ISO 3166-1 alpha-2 ("DE"). The PMS accepts every assigned code, so the register is never filtered. */
+type CountryCode = string;
+/** A select option: the code and its label in the requested language. */
+type CountryOption = readonly [code: CountryCode, label: string];
+/** A featured group pinned on top plus the rest of the register, collated by locale. A featured code
+ *  appears ONLY in `featured`: a duplicate made the select's scroll-to-selected land on the alphabetical
+ *  twin, hiding the pinned group. Serializable: computed at build, passed to islands. */
+interface CountryGroups {
+  /** The pinned group, in the site's order. */
+  readonly featured: readonly CountryOption[];
+  /** Every other country, collated by the locale. */
+  readonly all: readonly CountryOption[];
+}
+/** DACH. Sites add their audience (DK, NL, PL …) or reorder (CH first) through `featured`. */
+export declare const DEFAULT_FEATURED_COUNTRIES: readonly CountryCode[];
+/** What `countryOptions` labels. */
+interface CountryOptionsInput {
+  /** Label language, e.g. "de-DE" or "en". */
+  readonly locale: string;
+  /** Codes pinned on top, in this order. Default `DEFAULT_FEATURED_COUNTRIES`; codes outside the
+   *  register and repeats are skipped. */
+  readonly featured?: readonly CountryCode[];
+}
+/** The register as select options. Labels via `Intl.DisplayNames` — call at BUILD time. */
+type CountryOptions = (input: CountryOptionsInput) => CountryGroups;
+/** E.164 calling code (digits, no "+") for Europe and the common overseas origins, else undefined —
+ *  never a guessed prefix (a wrong one turns a national number into someone else's). */
+type DialCode = (code: CountryCode) => string | undefined;
 /**
- * The smallest external store that every UI framework can subscribe to:
- * `getState` + `subscribe` is what React's useSyncExternalStore, Vue's
- * watchers, Svelte's store contract and a plain `<script>` all understand.
- * Flows in this package (checkout today, more later) build on it so the
- * package never depends on a framework; the adapters live in ./react and
- * friends.
+ * Preselect from the visitor's languages (pass `navigator.languages`): non-English tags first (maximized:
+ * "da" → DK), because an added language is a real choice while an English UI is often just the OS
+ * default; then English tags with an explicit region ("en-GB"; bare "en" is never maximized — that guesses
+ * US for the world's default UI language); else `fallback` (default "DE"). Only codes in `countries`
+ * count; a malformed tag is skipped.
  */
-export type Listener<S> = (state: S) => void;
-export type Unsubscribe = () => void;
-export interface Store<S> {
-  getState(): S;
-  subscribe(listener: Listener<S>): Unsubscribe;
+type DetectCountry = (countries: CountryGroups, languages: readonly string[], fallback?: CountryCode) => CountryCode;
+/** See {@link CountryOptions}. */
+export declare const countryOptions: CountryOptions;
+/** See {@link DialCode}. */
+export declare const dialCode: DialCode;
+/** See {@link DetectCountry}. */
+export declare const detectCountry: DetectCountry;
+//#endregion
+//#region src/favorites/favorites.d.ts
+/** The window event every site script listens to (`detail: FavoritesChange`); kept verbatim. The
+ *  `./enhance` binder dispatches it from `onChange`. */
+export declare const FAVORITES_EVENT: "merkliste:changed";
+/** One rental saved or removed. */
+interface FavoritesChange {
+  /** The rental id. */
+  readonly id: string;
+  /** True when it was saved, false when it was removed. */
+  readonly saved: boolean;
+}
+/** `${namespace}-merkliste` — the kits' key shape. `namespace` is required and non-empty (throws
+ *  otherwise): the package carries no donor default; each site passes the namespace its kit code
+ *  resolves today (`PUBLIC_STORAGE_NS`, or the kit's fallback when unset). */
+type FavoritesStorageKey = (namespace: string) => string;
+/** The saved ids. */
+interface FavoritesState {
+  /** The saved rental ids. */
+  readonly ids: ReadonlySet<string>;
 }
-export interface WritableStore<S> extends Store<S> {
-  /** Replaces the state and notifies every listener. Same reference = no-op. */
-  setState(next: S): void;
+/** How a Merkliste is stored and reported. */
+interface FavoritesOptions {
+  /** `favoritesStorageKey(namespace)`. */
+  readonly storageKey: string;
+  /** Default `browserStorage("local")`; null = in memory (SSR, tests). Writes fail soft (quota, private
+   *  mode): the list then lasts for the visit. */
+  readonly storage?: StorageLike | null;
+  /** Receives every change, once per id (the binder dispatches `FAVORITES_EVENT` on window from it). */
+  readonly onChange?: (change: FavoritesChange) => void;
 }
-export declare function createStore<S>(initial: S): WritableStore<S>;
+/** A Merkliste store. Also satisfies the search store's `FavoritesPort` (`ids()` + `subscribe`). */
+interface Favorites extends Store<FavoritesState> {
+  /** The saved ids (the current state's set). */
+  ids(): ReadonlySet<string>;
+  /** Whether `id` is saved. */
+  has(id: string): boolean;
+  /** Save or remove `id`; returns the new saved state. */
+  toggle(id: string): boolean;
+  /** Make `id` saved or not; no change, no write, no `onChange`. */
+  set(id: string, saved: boolean): void;
+  /** Drop ids the site no longer knows (a rental that left the portfolio). */
+  prune(known: ReadonlySet<string>): void;
+  /** Re-read storage (another tab changed it: the `storage` event); reports each difference. */
+  reload(): void;
+  /** Stop: later calls change nothing and report nothing. */
+  dispose(): void;
+}
+/** The page's Merkliste for `options.storageKey`, shared through the registry so the binder, the
+ *  favourites page and every heart see one set. The first claim's `storage` wins; every claim's
+ *  `onChange` receives the changes until it is released. The last release disposes. */
+type AcquireFavorites = (options: FavoritesOptions) => {
+  readonly favorites: Favorites;
+  release(): void;
+};
+/** A Merkliste the caller owns. */
+type CreateFavorites = (options: FavoritesOptions) => Favorites;
+/** See {@link FavoritesStorageKey}. */
+export declare const favoritesStorageKey: FavoritesStorageKey;
+/** See {@link CreateFavorites}. */
+export declare const createFavorites: CreateFavorites;
+/** See {@link AcquireFavorites}. */
+export declare const acquireFavorites: AcquireFavorites;
 //#endregion
-//#region src/sdk.d.ts
-export type WebsiteSdk = ReturnType<typeof createWebsiteSDK>;
-/** Deployment stage: selects the public endpoint set below. */
-export declare const STAGES: readonly ["development", "production"];
-export type Stage = (typeof STAGES)[number];
-/** Public endpoints of the v10 backend per stage. */
-export declare const VOFFICE_ENDPOINTS: Record<Stage, {
-  apiEndpoint: string;
-  imageBaseUrl: string;
-  searchEndpoint: string;
-}>;
-/** Public endpoints of the v9 backend per stage; API URLs derive from `apiBaseUrl`. */
-export declare const HUB_ENDPOINTS: Record<Stage, {
-  apiBaseUrl: string;
-  imageProxyBaseUrl: string;
-}>;
-/** Everything the SDK needs, as plain public values — a static site has no
- *  secret to protect. Serializable on purpose: an Astro island receives it as a
- *  prop, so the site reads its env once (in .astro / a loader) and never inside
- *  a component. */
-export type SdkConfig = {
-  backend: "v9";
-  imageProxyBaseUrl: string;
-  v0ApiBaseUrl: string;
-  v1ApiBaseUrl: string;
-  graphqlUrl: string;
-  apiKey: string;
-} | {
-  backend: "v10";
-  imageBaseUrl: string;
-  apiEndpoint: string;
-  searchEndpoint: string;
-  accessToken: string;
+//#region src/guests/guest-search.d.ts
+/** Options of a guest search. Everything has a default. */
+interface GuestSearchOptions extends GuestOptions {
+  /** Start at defaultAdults when the URL states no party (closed field reads "2 Gäste"). Default false. Same
+   *  name as SearchBar `guests.showDefault` (one name in both layers). */
+  readonly showDefault?: boolean;
+  /** A rental's caps (booking contexts); the search bar passes none. */
+  readonly caps?: GuestCaps;
+}
+/** The guest search as a UI reads it. */
+interface GuestSearchState {
+  /** The chosen party: offered types clamped to their bounds, ages aligned to the children; adults 0 = none
+   *  chosen. A not-offered type keeps the value it was loaded with. */
+  readonly party: Party;
+  /** The adults a submit sends: chosen, or defaultAdults. What the adult stepper and the summary show. */
+  readonly shownAdults: number;
+  /** Any offered type has a count (drives prompt vs summary on the closed field). */
+  readonly hasSelection: boolean;
+  /** Every child has an age; always true while children are not offered (no one could enter one). */
+  readonly agesComplete: boolean;
+  /** Per type: whether a control renders, and its stepper bounds. */
+  readonly bounds: GuestBounds;
+  /** The selectable child ages, `childAge.min`..`childAge.max`. */
+  readonly ageOptions: readonly number[];
+  /** What a submit sends; a not-offered type keeps the URL's value ("hidden means not offered, never not honoured"). */
+  readonly occupancy: Party;
+}
+/** A framework-free guest search: read `getState()`, `subscribe`, call actions. */
+interface GuestSearch extends Store<GuestSearchState> {
+  /** Set one count, clamped to its bound; ignored for a type that is not offered. Fewer children drop the
+   *  trailing ages, more children add unchosen ones. */
+  set(kind: GuestKind, count: number): void;
+  /** Choose (or clear with null) child `index`'s age; an age outside the band or a missing child is ignored. */
+  setAge(index: number, age: number | null): void;
+  /** Restore from a read party (the URL); null = nothing stated. Ages outside the band become unchosen, so the
+   *  guest is asked again instead of priced for an age they did not give. */
+  load(party: Party | null): void;
+  /** Back to nothing chosen (or the default party with `showDefault`). */
+  reset(): void;
+  /** Change options; the party is re-clamped. Equal options are a no-op. */
+  update(options: Partial<GuestSearchOptions>): void;
+}
+/** A guest search; options are plain data (islands) and default to the kit values. */
+type CreateGuestSearch = (options?: GuestSearchOptions) => GuestSearch;
+/** See {@link CreateGuestSearch}. */
+export declare const createGuestSearch: CreateGuestSearch;
+//#endregion
+//#region src/search-bar/date-search.d.ts
+/** Which half of the picker is active. */
+type DateMode = "dates" | "flexible";
+/** Options of a date search. Everything has a default; only `backend` is required. */
+interface DateSearchOptions {
+  /** Which PMS answers (decides the flexible tab and how a ± step is spelled). */
+  readonly backend: BackendKind;
+  /** See `SearchContract.nightRangeSearch`. Default true. */
+  readonly nightRangeSearch?: boolean;
+  /** ± chips in days. Default [0, 1, 2, 3, 7, 14]; [] or [0] = no chip row. Shown on v10 always, on v9 only with
+   *  nightRangeSearch. */
+  readonly flexSteps?: readonly number[];
+  /** Default ["weekend", "week", "month"]; [] removes the tab; only where supportsFlexiblePeriodSearch. */
+  readonly flexibleStays?: readonly FlexibleStay[];
+  /** Render the Min./Max. Nächte row (presentation; whether the backend prices the pair is
+   *  `nightRangeSearch`). Default false. */
+  readonly nightRangeRow?: boolean;
+  /** Shortest pickable stay in nights; closer departure days are disabled. Default 1. */
+  readonly minStayNights?: number;
+  /** Not bookable online yet: `from` floors calendar, month strip and ± windows; `deferred` (the notice) is true
+   *  while today < `noticeUntil ?? from` (`contact` is the component's, ignored here). */
+  readonly bookable?: BookableFrom;
+  /** The clock, for tests. Default `() => new Date()`; read on every action, so a bar left open past
+   *  midnight moves its floor with the day. */
+  readonly now?: () => Date;
+}
+/** Which controls a UI renders right now. Derived from the options, the backend and the current pick. */
+interface DateControls {
+  /** The Datum/Flexibel switch and the flexible half. */
+  readonly flexibleTab: boolean;
+  /** The ± chips to render, 0 (exact dates) first; empty = no chip row. */
+  readonly flexSteps: readonly number[];
+  /** The Min./Max. row: enabled, the backend prices the pair, exact dates (± 0) and a window of ≥ 2 nights. */
+  readonly nightRangeRow: boolean;
+}
+/** The date search, as a UI reads it. */
+interface DateSearchState {
+  /** The active half. */
+  readonly mode: DateMode;
+  /** Arrival of the guest's own stay (never the widened window). */
+  readonly from: IsoDay | null;
+  /** Departure of the guest's own stay; null while the second day is being picked. */
+  readonly to: IsoDay | null;
+  /** Active ± step; 0 = exact dates. */
+  readonly flexDays: number;
+  /** The night range in force, clamped to the window; null when the stay simply is the window. */
+  readonly nightRange: {
+    readonly min: number;
+    readonly max: number;
+  } | null;
+  /** The flexible stay length; null until chosen (nothing is preselected). */
+  readonly stay: FlexibleStay | null;
+  /** The flexible months, sorted. */
+  readonly months: readonly IsoMonth[];
+  /** Nights between `from` and `to` (0 until both are set). */
+  readonly windowNights: number;
+  /** What to render. */
+  readonly controls: DateControls;
+  /** Earliest selectable day: the later of today and `bookable.from`. */
+  readonly floor: IsoDay;
+  /** The "not bookable online yet" notice shows (today < `noticeUntil ?? from`). */
+  readonly deferred: boolean;
+  /** The twelve months the flexible strip offers, counted from the floor's month. */
+  readonly monthOptions: readonly IsoMonth[];
+  /** What a submit sends now; null until a complete period is picked. */
+  readonly period: SearchPeriod | null;
+}
+/** A framework-free date search: read `getState()`, `subscribe`, call actions. */
+interface DateSearch extends Store<DateSearchState> {
+  /** A calendar click: the first sets `from`; the second sets `to` (a day before `from` moves `from`); a click
+   *  on a finished stay starts a new one there. Every pick resets the night range to the new window. Disabled
+   *  days are ignored. */
+  pick(day: IsoDay): void;
+  /** Before the floor; while `to` is being picked, departure days closer than `minStayNights`. */
+  isDisabled(day: IsoDay): boolean;
+  /** Ignored for "flexible" while the flexible tab is not offered. */
+  setMode(mode: DateMode): void;
+  /** Ignored for a step not in `controls.flexSteps`; a step > 0 clears the night range. */
+  setFlexDays(days: number): void;
+  /** Moving one bound past the other pushes the other along (the SDK refuses min > max). */
+  setMinNights(nights: number): void;
+  /** See `setMinNights`. */
+  setMaxNights(nights: number): void;
+  /** Ignored for a stay not in `flexibleStays`. */
+  setStay(stay: FlexibleStay): void;
+  /** Add or remove a month of `monthOptions`. */
+  toggleMonth(month: IsoMonth): void;
+  /** Restore from a read period (the URL). A period the controls cannot show (a step not offered, a range
+   *  without the row, a stay before the floor, a flexible stay not offered) loads as empty. */
+  load(period: SearchPeriod | null): void;
+  /** Nothing picked, exact-dates mode. */
+  reset(): void;
+  /** Change options (not the backend); a pick the new options cannot show is cleared. Equal options are a no-op. */
+  update(options: Partial<Omit<DateSearchOptions, "backend">>): void;
+}
+/** A date search over `options`. */
+type CreateDateSearch = (options: DateSearchOptions) => DateSearch;
+/** See {@link CreateDateSearch}. */
+export declare const createDateSearch: CreateDateSearch;
+//#endregion
+//#region src/search-bar/period-label.d.ts
+/** A period's summary parts, formatted for the locale. */
+interface PeriodLabel {
+  /** "4. – 11. Sept.", "30. Dez. 2026 – 3. Jan. 2027"; null before a day is picked (and on flexible periods). */
+  readonly dates: string | null;
+  /** The ± step; 0 = exact dates. */
+  readonly flexDays: number;
+  /** The night range inside the window, or null. */
+  readonly nights: {
+    readonly min: number;
+    readonly max: number;
+  } | null;
+  /** The flexible stay, or null. */
+  readonly stay: FlexibleStay | null;
+  /** "Sept. 2026" for one month, "Sept., Okt." for several (sorted; a month outside the current year carries
+   *  its year); null when not flexible. */
+  readonly months: string | null;
+}
+/** A picker's unfinished selection (an arrival, maybe a departure), described while it is being picked. */
+type PartialPeriod = {
+  readonly kind: "partial";
+  readonly from: IsoDay;
+  readonly to: IsoDay | null;
 };
-/** The three values a site actually decides — backend, stage, its token — as
- *  a full `SdkConfig`, with the endpoints the platform owns. */
-export declare function sdkConfigFor({ backend, stage, token }: {
-  backend: SdkConfig["backend"];
-  stage: Stage;
-  token: string;
-}): SdkConfig;
-/** Build an SDK instance from a config (+ the SDK's options: translation
- *  overrides, custom attributes, highlight prioritization). The caller owns the
- *  lifecycle and calls `await sdk.dispose()` when done. The API is rate-limited
- *  (1/s), so a browser surface keeps ONE instance for its lifetime. */
-export declare function createSdk(config: SdkConfig, options?: WebsiteSDKOptions): WebsiteSdk;
-/**
- * Render `error` and its whole cause chain as indented JSON.
- *
- * Walks the chain because a cause nests (a `CoreSDKError` wrapping a thrown
- * transport object wrapping a response body). Skips `stack` — a backend
- * refusal is not diagnosed from the frames that asked, and the raw error is
- * one `console.error` away for the cases that are. Reads `name`/`message` by
- * hand because `Error` declares both non-enumerable, so `Object.entries`
- * alone would return an Error as `{}`.
- *
- * **`cause` is read by hand for exactly the same reason**, and it was missed
- * the first time — so this file shipped without the one property it exists to
- * print. Verified against the real class: `Object.keys(new CoreSDKError({…}))`
- * is `["source", "operation", "_tag"]`, and `cause`'s own descriptor carries
- * `enumerable: false`. `Object.entries` therefore never saw it, and every
- * `CoreSDKError` logged as the five bland fields above with the sentence that
- * names the fault dropped.
- */
-export declare function describeSdkError(error: unknown): string;
-/**
- * Log a failed SDK call with the backend's reason, tagged by `scope`.
- *
- * `scope` names the SDK operation, not the component — `"quote.selectInsurance"`
- * rather than `"the extras panel"`. What the console needs to answer is which
- * call the backend refused; which button was on screen at the time is the part
- * the reporter already knows.
- *
- * Logs the description ALONE. Callers that also have the raw error in hand may
- * log it separately for a clickable stack; doubling it here would print every
- * failure twice on the surfaces that already do.
- */
-export declare function logSdkFailure(scope: string, error: unknown): void;
+/** Month once within a month, year only when not the current one, months through Intl ("Sept."). */
+type FormatStayRange = (from: IsoDay, to: IsoDay | null, locale: Locale, today?: IsoDay) => string;
+/** The summary parts of a period (or a partial pick, or nothing). `today` decides the current year. */
+type DescribePeriod = (period: SearchPeriod | PartialPeriod | null, locale: Locale, today?: IsoDay) => PeriodLabel;
+/** See {@link FormatStayRange}. */
+export declare const formatStayRange: FormatStayRange;
+/** See {@link DescribePeriod}. */
+export declare const describePeriod: DescribePeriod;
 //#endregion
-//#region src/quote.d.ts
-/** One row of the price breakdown. `label`/`amount` are the SDK's own
- *  `position`/`appliedCharge`, verbatim; `nested` marks a sub-line so the UI
- *  can indent it under the line above.
- *
- *  `discount` marks a row synthesised from an SDK price MODIFIER rather than
- *  from a charge line — see `adaptGuestQuote` for why those rows exist. Its
- *  `amount` is the modifier's own signed string ("-140,00 €"), so the row is a
- *  deduction from the running total, not another charge. */
-export interface QuoteLine {
+//#region src/search-bar/rental-jump.d.ts
+/** One rental a guest can jump to. `href` is the site's own detail URL (never re-derived from the name, which
+ *  broke umlauts and duplicate names). */
+interface RentalIndexEntry {
+  /** PMS rental id. */
+  readonly id: string;
+  /** The name shown and matched. */
+  readonly name: string;
+  /** The rental's detail page on this site. */
+  readonly href: string;
+  /** Object number or another code a guest may type ("10503"); an exact code ranks first. */
+  readonly code?: string;
+  /** A place shown beside the name (matched too: "name place" finds the rental). */
+  readonly place?: string;
+}
+/** How many hits and from which query length. */
+interface RentalMatchOptions {
+  /** Hits returned. Default 8. */
+  readonly limit?: number;
+  /** Shorter queries match nothing (one letter matches the whole catalogue). Default 2. */
+  readonly minChars?: number;
+}
+/** The hits for one query. */
+interface RentalMatch {
+  /** The best hits, at most `limit`. */
+  readonly hits: readonly RentalIndexEntry[];
+  /** All matches, for "{count} weitere". */
+  readonly total: number;
+}
+/** Lowercase, ä→ae ö→oe ü→ue ß→ss, other diacritics stripped, non-alphanumerics to one space. */
+type FoldSearchText = (raw: string) => string;
+/** Every query word must occur in name, place or code (indexed in both umlaut spellings: "duene" and "dune"
+ *  find "Düne"). Rank: code exact, name exact, name prefix, word start, contains; ties keep the index order. */
+type MatchRentals = (entries: readonly RentalIndexEntry[], query: string, options?: RentalMatchOptions) => RentalMatch;
+/** Fetched once per URL per page; a failure is not cached (the next call retries). Rows without a string id,
+ *  name and href are dropped. */
+type LoadRentalIndex = (url: string) => Promise<readonly RentalIndexEntry[]>;
+/** Build-time: index entries from the catalogue (the site's own slugs/hrefs); `place` is the rental's town. */
+type RentalIndexEntries = (rentals: readonly RentalDetail[], href: (rental: RentalDetail) => string, options?: {
+  readonly code?: (rental: RentalDetail) => string | undefined;
+}) => RentalIndexEntry[];
+/** See {@link FoldSearchText}. */
+export declare const foldSearchText: FoldSearchText;
+/** See {@link MatchRentals}. */
+export declare const matchRentals: MatchRentals;
+/** See {@link LoadRentalIndex}. */
+export declare const loadRentalIndex: LoadRentalIndex;
+/** See {@link RentalIndexEntries}. */
+export declare const rentalIndexEntries: RentalIndexEntries;
+//#endregion
+//#region src/search-bar/search-form.d.ts
+/** A field of the bar, in render order. "pets" = render the dog control as its own field after guests (instead
+ *  of inside the guest panel); which control it is follows `guests.limits.pets` (1 a yes/no toggle, more a
+ *  stepper). "pets" in `fields` while dogs are not offered (`guests.limits.pets` 0) is a spec
+ *  error: `createSearchForm` throws (build time), never renders an empty field. "region" renders only with at
+ *  least one region. */
+type SearchField = "region" | "dates" | "guests" | "pets";
+/** Options of a search form: the site's search contract plus what the bar asks. */
+interface SearchFormOptions extends SearchContract {
+  /** Default ["region", "dates", "guests"]; an absent field's key is carried, not owned (a `?region=` scope
+   *  survives a re-search from a bar without a region field). */
+  readonly fields?: readonly SearchField[];
+  /** The selectable region values (labels are UI); URL values outside the list self-hide. */
+  readonly regions?: readonly string[];
+  /** Default "multi" (OR). "single": one region or all. */
+  readonly regionSelect?: "multi" | "single";
+  /** The date picker's options. */
+  readonly dates?: Omit<DateSearchOptions, "backend" | "nightRangeSearch">;
+  /** The guest picker's options. */
+  readonly guests?: GuestSearchOptions;
+  /** Default "required": a child without age stops the submit. "optional" submits the ages that exist. */
+  readonly childAges?: "required" | "optional";
+  /** A landing page's starting search as a query string; its owned keys seed the pickers only when the URL owns
+   *  none of the bar's keys, its other pairs are submitted with every search from this bar. */
+  readonly preset?: string;
+  /** The clock, for tests. Default `() => new Date()` (read per URL read and per date action). */
+  readonly now?: () => Date;
+}
+/** Why a submit did not go out. */
+type SearchFormIssue = {
+  readonly kind: "agesMissing";
+};
+/** The search form as a UI reads it. */
+interface SearchFormState {
+  /** The fields that render: `fields` without "region" when there are no regions. */
+  readonly fields: readonly SearchField[];
+  /** The date picker. */
+  readonly dates: DateSearchState;
+  /** The guest picker. */
+  readonly guests: GuestSearchState;
+  /** Selected regions, in option order. */
+  readonly regions: readonly string[];
+  /** Pairs the bar does not own, carried through a submit (URL + preset). */
+  readonly carried: readonly QueryPair[];
+  /** false until load() ran (search pages show skeletons, submit disabled). */
+  readonly resolved: boolean;
+  /** Set by a refused submit, cleared by the next change. */
+  readonly issue: SearchFormIssue | null;
+}
+/** A framework-free search form: read `getState()`, `subscribe`, call actions. */
+interface SearchForm extends Store<SearchFormState> {
+  /** The composed date search (its actions drive the date panel). */
+  readonly dates: DateSearch;
+  /** The composed guest search (its actions drive the guest panel and the dog field). */
+  readonly guests: GuestSearch;
+  /** Multi: add or remove a region; single: choose it, or clear it when chosen. Values outside `regions` are ignored. */
+  toggleRegion(value: string): void;
+  /** Choose exactly one region; null = all regions. */
+  selectRegion(value: string | null): void;
+  /** No region chosen. */
+  clearRegions(): void;
+  /** Read the URL (and the preset) into the pickers; after hydration, the first render is the server's. */
+  load(search: string): void;
+  /** writeSearch(pickers) + carried — the GET form's hidden inputs. */
+  pairs(): QueryPair[];
+  /** The pairs to submit, or the issue that stops the submit (a child without an age, while "required").
+   *  `current` (pass `location.search`): the carried pairs are re-read from it first, so the filters, sort
+   *  and campaign a results page changed in place since `load` ride along (and a removed one stays
+   *  removed); the pickers keep the guest's unsubmitted choices. */
+  submit(current?: string): {
+    readonly ok: true;
+    readonly pairs: QueryPair[];
+  } | {
+    readonly ok: false;
+    readonly issue: SearchFormIssue;
+  };
+  /** Pickers and regions back to nothing chosen; the carried pairs stay. */
+  reset(): void;
+  /** Change options (not the backend); option objects are merged, equal options are a no-op. */
+  update(options: Partial<Omit<SearchFormOptions, "backend">>): void;
+  /** Stop listening to the composed stores. */
+  dispose(): void;
+}
+/** A search form over `options`; throws on a spec error ("pets" in `fields` while dogs are not offered). */
+type CreateSearchForm = (options: SearchFormOptions) => SearchForm;
+/** See {@link CreateSearchForm}. */
+export declare const createSearchForm: CreateSearchForm;
+//#endregion
+//#region src/search/run.d.ts
+/** One request's options: the search contract, links and facts, filters and paging. */
+interface LiveSearchOptions extends ResultLinkOptions, SearchContract {
+  /** The resolved filters: their sdk keys reach the SDK, retired keys never do. */
+  readonly filters?: ResolvedFilters | null;
+  /** Default "recommended". */
+  readonly sort?: SortKey;
+  /** The previous page's cursor (opaque). */
+  readonly cursor?: string | null;
+  /** v10 only: server-side id restriction (favourites, a fixed set); ignored on v9. */
+  readonly rentalIdsIn?: readonly string[];
+}
+/** One page of the live search. */
+interface SearchPage {
+  /** The rentals of this page, exact matches first. */
+  readonly items: readonly SearchResultItem[];
+  /** What kind of search the page answers. */
+  readonly shape: QueryShape;
+  /** The next page's cursor. */
+  readonly cursor: string | null;
+  /** The backend has another page. */
+  readonly hasNextPage: boolean;
+  /** `pageInfo.totalCount` when the backend states it. */
+  readonly totalCount: number | null;
+  /** Keys the backend reports as having had no effect. */
+  readonly unusedFilterKeys: readonly string[];
+}
+/** One request with the caller's SDK (never created or disposed here); failures are logged as
+ *  "search.search" by the SDK module and rethrown. */
+type RunLiveSearch = (sdk: WebsiteSdk, search: string, options: LiveSearchOptions) => Promise<SearchPage>;
+/** See {@link RunLiveSearch}. */
+export declare const runLiveSearch: RunLiveSearch;
+//#endregion
+//#region src/search/registry.d.ts
+/** A claim on the page's store under one key; the last `release` disposes it. */
+interface SearchStoreClaim {
+  /** The page's store under the key. */
+  readonly store: SearchStore;
+  /** Drop this claim (idempotent); the last release disposes the store. */
+  release(): void;
+}
+/** The store under `key`, created by `create` when the page has none yet. The same key always
+ *  yields the same store; the last release disposes it. */
+type AcquireSearchStore = (key: string, create: () => SearchStore) => SearchStoreClaim;
+/** Attach to a store that may appear later (a satellite island hydrating before the results);
+ *  `onStore(null)` when it is released. Returns the detach. */
+type ConnectSearchStore = (key: string, onStore: (store: SearchStore | null) => void) => () => void;
+/** See {@link AcquireSearchStore}. */
+export declare const acquireSearchStore: AcquireSearchStore;
+/** See {@link ConnectSearchStore}. */
+export declare const connectSearchStore: ConnectSearchStore;
+//#endregion
+//#region src/showcase/select.d.ts
+/** How qualifying rentals are ordered before spreading, pins and the limit.
+ *  feed: as the candidates arrive (default) · name: by name (numeric-aware) · rating: rating
+ *  desc, then review count desc · reviews: review count desc, then rating desc · guests:
+ *  capacity desc, then name · shuffle: deterministic from `seed` (a build date gives "random
+ *  per build"). Missing values sort last; ties keep the feed order. */
+type ShowcaseOrder = "feed" | "name" | "rating" | "reviews" | "guests" | "shuffle";
+/** Who qualifies for a row and how the row is ordered, spread and gated. */
+interface SelectionSpec {
+  /** Who qualifies. Default: every candidate. */
+  match?: CardMatch;
+  /** These ids lead, in this order, whether or not they match (exclude and minImages still
+   *  apply). An id the candidates do not know throws: a typo must fail the build. */
+  pin?: readonly string[];
+  /** Fill after the pins from the matches. Default true; false = the pins only. */
+  fill?: boolean;
+  /** Ids never shown (the page's own rental). Default none. */
+  exclude?: readonly string[];
+  /** Default "feed". */
+  order?: ShowcaseOrder;
+  /** Seed of `order: "shuffle"`. Default "". */
+  seed?: string;
+  /** Round-robin across towns (or streets) after ordering, keeping the order inside each, so a
+   *  row opens on the town and not on one building. One town degrades to the order. */
+  spreadBy?: "location" | "street" | null;
+  /** Images a rental needs to qualify. Default 1. */
+  minImages?: number;
+  /** Rentals kept. Default: all. */
+  limit?: number;
+  /** Fewer than this → an empty selection (the section self-hides). Default 1; carousel rows 3
+   *  (two cards in a scrolling track read as broken). */
+  minSize?: number;
+  /** A match holding more than this share of the candidates says nothing → empty. Default: no
+   *  check. */
+  maxShare?: number;
+  /** Fewer than this throws at build, with the counts — for sections the customer requires.
+   *  Default: never. */
+  failBelow?: number;
+}
+/** A row's rentals and its honest total. */
+interface Selection {
+  /** The rentals kept, in row order. */
+  rentals: CardSource[];
+  /** Before `limit` — the honest "Alle {N}" (0 when a gate emptied the selection). */
+  total: number;
+}
+type SelectRentals = (candidates: readonly CardSource[], spec?: SelectionSpec) => Selection;
+/** Deterministic Fisher–Yates over mulberry32: the same seed gives the same order on every
+ *  visitor and reload. */
+type SeededShuffle = <T>(items: readonly T[], seed: string | number) => T[];
+/** See {@link SelectRentals}. */
+export declare const selectRentals: SelectRentals;
+/** See {@link SeededShuffle}. */
+export declare const seededShuffle: SeededShuffle;
+//#endregion
+//#region src/showcase/groups.d.ts
+/** One row as the site defines it. */
+interface ShowcaseGroupSpec {
+  /** The row's id (its tab, its rotation seed). */
+  id: string;
+  /** The row's heading or tab label. */
   label: string;
+  /** The tab text when the label is long. */
+  shortLabel?: string;
+  /** A glyph beside the label. Default none. */
+  icon?: Glyph;
+  /** Where this row's "see all" goes (a scoped search link). */
+  href?: string;
+  /** One or two sentences of site copy shown with the group (under the active tab, or under a
+   *  single group's heading). Site data, never derived. */
+  blurb?: string;
+  /** Who the row shows (`selectRentals`). */
+  select: SelectionSpec;
+}
+/** A row ready to render — the Showcase prop. Plain JSON. */
+interface ShowcaseGroup {
+  /** The row's id. */
+  id: string;
+  /** The row's heading or tab label. */
+  label: string;
+  /** The tab text when the label is long, or null. */
+  shortLabel: string | null;
+  /** A glyph beside the label, or null. */
+  icon: Glyph | null;
+  /** Where the row's "see all" goes, or null. */
+  href: string | null;
+  /** The row's site copy, or null. */
+  blurb: string | null;
+  /** Qualifying rentals before the row's limit. */
+  total: number;
+  /** The rentals shown, in row order. */
+  rentals: readonly CardSource[];
+}
+/** Rows in spec order; a row whose selection is empty is omitted. `distinct`: a rental shown in
+ *  an earlier row is not offered to later rows (default false — themed rows overlap by design;
+ *  "featured, then a dog row without them" sets true). */
+type BuildShowcaseGroups = (candidates: readonly CardSource[], specs: readonly ShowcaseGroupSpec[], options?: {
+  distinct?: boolean;
+}) => ShowcaseGroup[];
+/** See {@link BuildShowcaseGroups}. */
+export declare const buildShowcaseGroups: BuildShowcaseGroups;
+//#endregion
+//#region src/showcase/related.d.ts
+/** How "more rentals nearby" is chosen for a rental page. */
+interface RelatedOptions {
+  /** What "near" means: the same `location` (default) or a shared region. */
+  prefer?: "location" | "region";
+  /** Default 8. */
+  limit?: number;
+  /** Fewer than this → []. Default 2. */
+  minSize?: number;
+  /** Images a rental needs. Default 1. */
+  minImages?: number;
+}
+type SelectRelated = (candidates: readonly CardSource[], currentId: string, options?: RelatedOptions) => CardSource[];
+/** See {@link SelectRelated}. */
+export declare const selectRelated: SelectRelated;
+//#endregion
+//#region src/showcase/rotation.d.ts
+/** A fair rotation: which window of a row shows now. */
+interface RotationOptions {
+  /** Tiles shown at once. */
+  visible: number;
+  /** Minutes a window stands. */
+  minutes: number;
+  /** Epoch ms; default `Date.now()`. */
+  now?: number;
+  /** Mixed into every round's shuffle so rows do not rotate in lockstep (the group id). */
+  seed?: string;
+}
+/** The indices (0 … count − 1) to show now, in display order. `count <= visible` → all. */
+type RotationWindow = (count: number, options: RotationOptions) => number[];
+/** See {@link RotationWindow}. */
+export declare const rotationWindow: RotationWindow;
+//#endregion
+//#region src/showcase/search-groups.d.ts
+/** At least one of `rentalIds` and `filterQuery` (throws otherwise). */
+interface SearchGroupSpec {
+  /** The group's id (the row it fills). */
+  id: string;
+  /** Curated ids, in curated order. An id the catalogue does not know throws. */
+  rentalIds?: readonly string[];
+  /** A dateless filter query ("lakeview=true"). */
+  filterQuery?: string;
+  /** With both: pin every curated id first and fill from the matches (true), or keep only the
+   *  curated ids that also match, in curated order (false, default). */
+  pinCurated?: boolean;
+  /** Matches kept (pins always stay). Default 6. */
+  limit?: number;
+}
+/** A search-defined group resolved at build: its rentals and what the backend ignored. */
+interface ResolvedSearchGroup {
+  /** The spec's id. */
+  id: string;
+  /** The rentals, curated ones first where pinned. */
+  rentalIds: string[];
+  /** Keys the backend ignored — the category filters nothing on this tenant (the site decides
+   *  its fallback, e.g. a SelectionSpec). */
+  unusedFilterKeys: string[];
+}
+/** BUILD TIME. Specs in order; an empty category is returned empty, never dropped. A failed
+ *  or incomplete search rejects (the build fails and the previous build stays live). */
+type ResolveSearchGroups = (sdk: WebsiteSdk, specs: readonly SearchGroupSpec[], options: {
+  locale: Locale;
+  knownIds: ReadonlySet<string>;
+}) => Promise<ResolvedSearchGroup[]>;
+/** See {@link ResolveSearchGroups}. */
+export declare const resolveSearchGroups: ResolveSearchGroups;
+//#endregion
+//#region src/quote/availability.d.ts
+/** What a day IS for the stay being picked; exactly one per day, the UI maps it to a look.
+ *  - "past": before today.
+ *  - "booked": a hard status on the ARRIVAL map (`unavailable`, `after_last_bookable_date`,
+ *    `range_crosses_unavailable_date_and_is_unavailable`) — genuinely not bookable.
+ *  - "unreachable": departure phase only — a hard status on the END map for a day that is not booked:
+ *    the stay would cross a booked night. Kept apart from "booked" so a site can keep the struck set
+ *    stable while a start is chosen (a customer ruling: no jumps while picking).
+ *  - "restricted": available, but a rule blocks it in this phase (no check-in, minimum stay, no
+ *    check-out, the site's `minStayNights`), or the map for this phase is not in yet.
+ *  - "free": selectable in this phase. */
+type DayKind = "past" | "booked" | "unreachable" | "restricted" | "free";
+/** One calendar day, ready to render. */
+interface DayState {
+  /** The day. */
+  iso: IsoDay;
+  /** What the day is in the current phase. */
+  kind: DayKind;
+  /** A click does something now: free in this phase, or the chosen start while picking the end. */
+  selectable: boolean;
+  /** The SDK's formatted nightly price, raw (format it with `dayPriceLabel`), or null: none from the
+   *  SDK, past, booked, or a chosen endpoint. Shown on restricted days too — the hub's status decides,
+   *  not the phase (prices on rule-restricted free nights were hidden once; 157 priced days measured).
+   *  While the end is picked, the departure map's price when the SDK prices end dates (v9 from SDK
+   *  2.30), else the arrival price. */
+  price: string | null;
+  /** The SDK's localized block reason; only on a non-selectable day outside the chosen range (a
+   *  departure endpoint re-judged as "no arrival" must not flash its tooltip). */
+  reason: string | null;
+  /** Position in the chosen range. */
+  selection: "start" | "end" | "inside" | null;
+}
+/** The arrival map of one rental over a window. */
+interface InitialAvailability {
+  /** Days the SDK flags as a possible check-in. */
+  canStart: ReadonlySet<IsoDay>;
+  /** Days with a hard status: genuinely not bookable (struck), as opposed to rule-blocked (dimmed). */
+  hardBlocked: ReadonlySet<IsoDay>;
+  /** The SDK's raw `formattedPrice` by day (already localized, in the rental's booking currency). */
+  priceByDay: ReadonlyMap<IsoDay, string>;
+  /** The SDK's localized `tooltip` by day (a block reason, or a stay-length hint). */
+  tooltipByDay: ReadonlyMap<IsoDay, string>;
+  /** Persons cap (adults + children) the SDK states; null when it states none (v9 before SDK 2.28). */
+  maxPersons: number | null;
+  /** Adults cap the SDK states; null when it states none (v9 before SDK 2.28). */
+  maxAdults: number | null;
+  /** false when the rental takes no children, babies included; null states no rule (v10, v9 before
+   *  SDK 2.28). */
+  childrenAllowed: boolean | null;
+  /** The most dogs the quote accepts, 0 for none; null states no limit (v10, v9 before SDK 2.28). */
+  maxPets: number | null;
+}
+/** The departure map for one chosen start. */
+interface EndAvailability {
+  /** The start this map answers for. */
+  start: IsoDay;
+  /** Days the SDK flags as a possible check-out (its minimum stay and check-out rules applied). */
+  canEnd: ReadonlySet<IsoDay>;
+  /** Days with a hard status for this start (booked, or a range crossing a booked night). */
+  hardBlocked: ReadonlySet<IsoDay>;
+  /** The SDK's raw `formattedPrice` by possible check-out day: the last night of a stay from `start`
+   *  to that day, at the rate for its length. null when the SDK prices no end dates (v10, v9 before
+   *  SDK 2.30). */
+  priceByDay: ReadonlyMap<IsoDay, string> | null;
+  /** The SDK's localized `tooltip` by day (minimum stay not met, no check-out, …). */
+  tooltipByDay: ReadonlyMap<IsoDay, string>;
+}
+/** What both fetchers take: the rental and the inclusive window the SDK computes over. */
+interface AvailabilityWindowInput {
+  /** PMS rental id (numeric unit id on v9). */
+  rentalId: string;
+  /** First day of the window. */
+  from: IsoDay;
+  /** Last day of the window. */
+  through: IsoDay;
+  /** Language of the SDK's tooltips. */
+  locale: Locale;
+}
+/** The departure-map input: the window plus the chosen start. */
+interface EndAvailabilityInput extends AvailabilityWindowInput {
+  /** The chosen check-in day. */
+  start: IsoDay;
+}
+/** How calendar CELLS state the nightly price; never a total.
+ *  - "rounded": whole units, half up (`formatPriceLabel(·, "round")`) — truncation would understate every
+ *    night, always in the direction that flatters the price.
+ *  - "exact": the SDK's figure with only a zero-cents group dropped ("120,00 €" → "120 €").
+ *  - "none": no figure in the cells (customer rulings on several sites). */
+type DayPrices = "rounded" | "exact" | "none";
+/** Possible check-in days, prices and caps for a rental (`availability.getInitialAvailability`). */
+type FetchInitialAvailability = (sdk: WebsiteSdk, input: AvailabilityWindowInput) => Promise<InitialAvailability>;
+/** Possible check-out days for one start (`availability.getStartDateSelectedAvailability`). */
+type FetchEndAvailability = (sdk: WebsiteSdk, input: EndAvailabilityInput) => Promise<EndAvailability>;
+/** The cell text for one SDK price string, or null for "none". A shape the price reader does not
+ *  recognise is returned unchanged (a display tidy never turns a price into a wrong one). */
+type DayPriceLabel = (formatted: string, mode: DayPrices) => string | null;
+/** See {@link FetchInitialAvailability}. */
+export declare const fetchInitialAvailability: FetchInitialAvailability;
+/** See {@link FetchEndAvailability}. */
+export declare const fetchEndAvailability: FetchEndAvailability;
+/** See {@link DayPriceLabel}. */
+export declare const dayPriceLabel: DayPriceLabel;
+//#endregion
+//#region src/quote/stay-picker.d.ts
+/** What the picker needs to know about the rental and the site. */
+interface StayPickerOptions {
+  /** PMS rental id. */
+  rentalId: string;
+  /** Language of the SDK's tooltips. */
+  locale: Locale;
+  /** Navigable months from the current one. Availability is fetched one month further, so the last
+   *  month's departures exist. Default 12. */
+  horizonMonths?: number;
+  /** The site's minimum stay in NIGHTS on top of the PMS rules: a departure closer to the start is
+   *  "restricted". A higher PMS minimum still wins (the SDK's `canEnd` already encodes it). */
+  minStayNights?: number;
+  /** Clock, for tests. Default `() => new Date()`. */
+  now?: () => Date;
+}
+/** The picker's state; serializable apart from nothing — every value is a string, number or null. */
+interface StayPickerState {
+  /** The arrival map. "error": the calendar could not load (never rendered as a full calendar). */
+  availability: "loading" | "ready" | "error";
+  /** First and last navigable days (the fetch reaches one month past `through`). */
+  window: {
+    from: IsoDay;
+    through: IsoDay;
+  };
+  /** The chosen stay so far. */
+  range: {
+    start: IsoDay | null;
+    end: IsoDay | null;
+  };
+  /** arrival: no start · departure: a start, no end · complete: both. */
+  phase: "arrival" | "departure" | "complete";
+  /** The departure map for `range.start`. While "loading" only the start is selectable; a failed load
+   *  is logged and becomes an empty map (no departure), never a silent free-for-all. */
+  departures: "idle" | "loading" | "ready";
+  /** Occupancy caps from the arrival map; null until it lands or when the SDK states none. */
+  caps: Pick<InitialAvailability, "maxPersons" | "maxAdults" | "childrenAllowed" | "maxPets">;
+  /** First arrivable day in the window, or null: a sheet scrolls there, AvailabilityCalendar opens there. */
+  firstArrival: IsoDay | null;
+  /** Nights of a complete range, else null. */
+  nights: number | null;
+  /** Bumped on every map change, so a memoized calendar knows to re-read `day()`. */
+  revision: number;
+}
+/** The picker: a store plus the day model and the picking actions. */
+interface StayPicker extends Store<StayPickerState> {
+  /** The render model of one day in the current phase. Pure over the state and the maps. */
+  day(iso: IsoDay): DayState;
+  /** A click: sets the start (and fetches its departures), completes the range, deselects the start
+   *  when clicked again, or — on a complete range — starts a new one (the third click). A
+   *  non-selectable day is ignored. */
+  select(iso: IsoDay): void;
+  /** Programmatic range (handover, checkout editor, next arrival). Re-validated against the arrival
+   *  map once it is in: an arrival the PMS refuses clears the range rather than pricing it; a range
+   *  shorter than `minStayNights` keeps only its start. */
+  setRange(start: IsoDay, end: IsoDay | null): void;
+  /** Back to the arrival phase, nothing chosen. */
+  reset(): void;
+  /** Replace the site's minimum stay (absent = none); the range is re-validated against it. */
+  configure(options: Pick<StayPickerOptions, "minStayNights">): void;
+  /** Fetch the arrival map. Idempotent; nothing is fetched before it is called. */
+  start(): void;
+  /** Stop: late answers are dropped. */
+  dispose(): void;
+}
+/** A picker over the caller's SDK, resolved once on the first request (again only after a failed
+ *  resolve). Requests: one arrival map per picker, one departure map per chosen start (the SDK queues
+ *  and caches them per rental). */
+type CreateStayPicker = (sdk: SdkSource, options: StayPickerOptions) => StayPicker;
+/** See {@link CreateStayPicker}. */
+export declare const createStayPicker: CreateStayPicker;
+//#endregion
+//#region src/quote/adapter.d.ts
+/** One row of the price breakdown. Strings are the SDK's, verbatim. */
+interface PriceLine {
+  /** charge: a card line · sub: its sub-item (indented) · discount: a PMS modifier row under the line
+   *  it adjusts (a deduction, rarely a surcharge). */
+  kind: "charge" | "sub" | "discount";
+  /** The SDK's `position` (or the modifier's label). */
+  label: string;
+  /** The figure of the default ("rows") display: the line's `totalBeforeModifiers` when it carries
+   *  modifiers, so gross − deduction rows add up to the total; else `appliedCharge`. On a discount row
+   *  the modifier's signed amount. */
   amount: string;
-  nested: boolean;
-  discount: boolean;
-}
-export interface PriceQuote {
-  /** Section/line breakdown flattened in SDK order (sub-items follow their
-   *  parent line, flagged `nested`). */
-  lines: QuoteLine[];
-  /** SDK `bookingCardInformation.total`, verbatim (already locale-formatted). */
+  /** `appliedCharge` (net of its modifiers); equal to `amount` on a line without modifiers. The
+   *  "struck-total" display annotates these net lines with the discount rows. */
+  netAmount: string;
+}
+/** The price card of one quote. */
+interface PriceView {
+  /** `bookingCardInformation.total`, verbatim. */
   total: string;
+  /** The PMS's own pre-modifier card total; null without modifiers (v9 always). The only struck price
+   *  the package ever prints, and only where a site chose to. */
+  totalBeforeModifiers: string | null;
+  /** The breakdown in SDK order; sub and discount rows follow the charge they belong to. */
+  lines: PriceLine[];
+  /** Distinct labels of the deductions in first-seen order (the PMS's words, e.g. a campaign name).
+   *  Surcharges are not offers and are left out. */
+  offerLabels: string[];
 }
-/** Bookable add-on from `quote.additionalServices`, verbatim fields. */
-export interface QuoteAddonService {
+/** A bookable add-on from `quote.additionalServices`, verbatim fields. */
+interface QuoteAddonService {
+  /** The service id the selection calls take. */
   id: string;
+  /** The PMS's name, verbatim. */
   label: string;
-  /** SDK charge string as-is (e.g. "25,00 €" — the PMS's own formatting). */
+  /** The SDK's charge string as-is ("25,00 €"). */
   charge: string;
+  /** The PMS's description, verbatim. */
   description?: string | undefined;
   /** Max selectable per booking; absent = the SDK states no cap. */
   maxPerBooking?: number | undefined;
-  /** Quantity the PMS PROPOSES for this service (`0` included). A proposal,
-   *  NOT a selection — the distinction is the whole reason this field is
-   *  named the way it is.
-   *
-   *  THE SDK IS EXPLICIT (`instructions/quote.md`): "When the backend provides
-   *  a line amount for an optional service, it is exposed as `proposedQuantity`
-   *  (including `0`). By default this is informational only and is not added to
-   *  the quote." A fresh quote carries these as selections ONLY on a project
-   *  that sets `shouldAddProposedAdditionalServiceAmount: true`, which the SDK
-   *  defaults to `false`.
-   *
-   *  SO THIS IS NEVER A BASELINE. What a quote actually has selected is not
-   *  readable from the public SDK surface at all — `GuestQuote` keeps its
-   *  `selections` behind an unexported symbol, and there is no quote-side
-   *  counterpart to `getBookingModificationSelectedQuantity`. Code that needs a
-   *  known starting point therefore MAKES one with `clearQuoteServices` and
-   *  steps up from zero. It does not read this number and hope.
-   *
-   *  RENAMED FROM `preSelectedQuantity` IN booking-kit 1.21.0, because the old
-   *  name stated the one thing the value does not mean, and `checkout-kit`
-   *  believed it — see that kit's 1.21.0 entry. */
+  /** The quantity the PMS PROPOSES (`0` included) — a proposal, never a selection: a fresh quote
+   *  carries it as selected only when the SDK option `shouldAddProposedAdditionalServiceAmount` is on,
+   *  and the quote does not say which. Code that needs a known start clears and steps up from zero. */
   proposedQuantity: number;
-  /** False only when the PMS explicitly marks this service unbookable for the
-   *  current multi-rate combination (SDK `available: false`). Absent → true.
-   *  The UI disables adding it rather than letting the click silently no-op. */
+  /** False only when the PMS marks the service unbookable for the current combination. */
   available: boolean;
-  /** PMS's own reason the service is unavailable, verbatim; self-hides when
-   *  the feed omits it. */
+  /** The PMS's reason it is unavailable, verbatim; absent when the feed states none. */
   unavailableReason?: string | undefined;
+  /** The service's pictures from the feed (alt verbatim). */
+  images?: readonly CardImage[] | undefined;
 }
-export interface QuotePolicyRule {
+/** One refund rule of a cancellation policy. */
+interface QuotePolicyRule {
+  /** Cancel at least this many days before arrival … */
   daysBeforeArrival: number;
-  /** SDK's formatted percentage string, verbatim. */
+  /** … and get this back: the SDK's formatted percentage ("100 %"), verbatim. */
   refundPercentage: string;
 }
-/** Selectable cancellation policy from `quote.cancellationPolicies`. */
-export interface QuoteCancellationPolicy {
+/** A selectable cancellation policy from `quote.cancellationPolicies`. */
+interface QuoteCancellationPolicy {
+  /** The policy id `selectQuotePolicy` and `?policy=` take. */
   id: string;
+  /** The host's name, or one of the PMS's built-in names (see `isBuiltInPolicy`). */
   label: string;
+  /** The rate this quote is priced under. */
   selected: boolean;
+  /** The PMS's prose, verbatim (often an echo of the label; see `policyTerms`). */
   description?: string | undefined;
+  /** Present on alternative rates ("-20%"); the base rate carries none. */
   markUpPercentage?: string | undefined;
+  /** A separate charge for cancelling, formatted by the SDK. */
   processingFee?: string | undefined;
+  /** The refund ladder; empty on the SDK's minimal policy. */
   rules: QuotePolicyRule[];
-  /** False only when the PMS explicitly marks this policy unselectable for the
-   *  current multi-rate combination (SDK `available: false`). Absent → true. */
+  /** False only when the PMS marks the policy unselectable for the current combination. */
   available: boolean;
-  /** PMS's own reason the policy is unavailable, verbatim; self-hides when
-   *  the feed omits it. */
+  /** The PMS's reason for `available: false`, verbatim. */
   unavailableReason?: string | undefined;
 }
-/** Voucher status echoed back on a re-priced quote (`quote.voucher`). On v10
- *  the SDK authoritatively reports whether the code applied a modifier; v9
- *  reports `"unknown"`. `message` is the PMS's own note, verbatim. */
-export interface QuoteVoucher {
+/** The voucher status echoed on a re-priced quote (v10 authoritative, v9 "unknown"). */
+interface QuoteVoucher {
+  /** The code as submitted. */
   code: string;
+  /** v10 says whether a voucher modifier applied; v9 always answers "unknown". */
   status: "applied" | "not_applied" | "unknown";
+  /** The PMS's own note, verbatim. */
   message?: string | undefined;
 }
-/** One selectable travel-insurance product from `quote.insurance.options`
- *  (kind "insurance"), verbatim fields. The backend loads these live from
- *  whichever insurer the hub setup configures, and only when that setup enables
- *  insurance at all — otherwise the SDK returns the "none" option alone and the
- *  adapter yields no `QuoteInsurance`. */
-export interface QuoteInsuranceOption {
+/** One selectable travel-insurance product (`quote.insurance.options`, kind "insurance"). */
+interface QuoteInsuranceOption {
+  /** The plan id `selectQuoteInsurance` takes. */
   id: string;
+  /** The product name; the identity the checkout keys documents on. */
   label: string;
-  /** SDK's own locale-formatted premium (e.g. "14,00 €"). There is no numeric
-   *  amount on the public shape — the SDK keeps that internally — so a premium
-   *  can be DISPLAYED but never added to another price. */
+  /** The SDK's formatted premium; displayable, never added to another price. */
   formattedPrice: string;
+  /** The insurer's description, verbatim. */
   description?: string | undefined;
-  /** Insurer logo, when the feed provides one. The kit's insurance card does
-   *  not render it; a site that wants the insurer's mark has it here. */
+  /** The insurer's logo, when the feed has one. */
   logoUrl?: string | undefined;
-  /** Plan feature names, verbatim (e.g. "Reiserücktritt"). */
+  /** Plan feature names, verbatim. */
   features?: string[] | undefined;
-  /** Product documents (IPID, Bedingungen, …) — label + URL, verbatim. */
+  /** Product documents (IPID, terms), label + URL verbatim. */
   resources?: {
     label: string;
     url: string;
   }[] | undefined;
-  /** True when the product needs per-traveler data before selection (the ERGO
-   *  path: traveler forms, pre-contract, SEPA mandate, a post-booking
-   *  `bookInsurance` call). False = the id alone completes the selection and
-   *  the premium books WITH the rental, because `booking.book` injects
-   *  `travelInsurancePlan`/`travelInsuranceAmount` from the quote for exactly
-   *  these products. The checkout only offers the ones it can complete. */
+  /** True when the product needs per-traveler data first (not completable by the checkout). */
   requiresTravelers: boolean;
 }
-/** Travel-insurance choice on a live quote (`quote.insurance`), flattened for
- *  the checkout's radio section. Absent from the view when the feed offers no
- *  real product (options empty or "none"-only) — the section self-hides.
- *
- *  The premium is NOT part of `card.total`: the SDK prices the stay and the
- *  policy separately, so a UI that shows both must show them as two figures.
- *  Adding them would mean parsing the PMS's formatted strings, which this file
- *  does not do for any other charge either. */
-export interface QuoteInsurance {
+/** The travel-insurance choice of a live quote. Absent from the view when the feed offers no real
+ *  product (v10's none-only placeholder): every insurance surface then self-hides. The premium is NOT
+ *  part of the card total. */
+interface QuoteInsurance {
   /** The SDK's own "no insurance" label, verbatim. */
   noneLabel: string;
+  /** The products the feed offers, verbatim. */
   options: QuoteInsuranceOption[];
   /** Selected product id, or null = no insurance (the default). */
   selectedId: string | null;
 }
-/** The renderable view of a live GuestQuote — card + selectable options. */
-export interface QuoteView {
-  card: PriceQuote;
+/** The renderable view of a live GuestQuote. */
+interface QuoteView {
+  /** The price card. */
+  price: PriceView;
+  /** Bookable add-ons, in SDK order. */
   services: QuoteAddonService[];
+  /** Cancellation policies, in SDK order, unfiltered (`offeredPolicies` decides what is offered). */
   policies: QuoteCancellationPolicy[];
-  /** Present once a code has been submitted and the quote re-priced; absent on
-   *  a fresh quote. */
+  /** Present once a code was submitted and the quote re-priced. */
   voucher?: QuoteVoucher | undefined;
-  /** Selectable travel insurance — absent when the feed offers no product. */
+  /** Present only when the feed offers a real product; the quote surface never renders it (the
+   *  checkout owns the § 7 VVG gate). */
   insurance?: QuoteInsurance | undefined;
 }
-export type QuoteResult = {
+/** Why the SDK refused to price a stay — the ONLY thing callers may branch on (`reason` is localized
+ *  and carries the same text for different codes). Derived from the SDK's result, never re-listed. */
+type QuoteUnavailableCode = Extract<GuestQuoteResult, {
+  status: "unavailable";
+}>["code"];
+/** The answer for one stay. */
+type QuoteResult =
+/** Priced: the live quote (required by `booking.book`, in memory only) and its view. */
+{
   status: "available";
-  /** Flattened price card (back-compat: the widget renders this). */
-  quote: PriceQuote;
-  /** The live SDK quote instance — required by booking.book. In-memory
-   *  only; not serializable across navigations. */
   live: GuestQuote;
-  /** Add-ons + policies for the checkout's optional sections. */
   view: QuoteView;
-} | {
+} |
+/** Refused: the SDK's localized reason and its machine code. */
+{
   status: "unavailable";
   reason: string;
   code: QuoteUnavailableCode;
 };
-/** Why the SDK refused to price the stay — machine-readable since website-sdk
- *  2.16.0, and the ONLY thing callers may branch on. `reason` is localized and
- *  carries the SAME text for different codes, so comparing it is how a UI ends
- *  up telling a guest a free week is booked out.
- *
- *  DERIVED from `GuestQuoteResult`, not re-listed: the SDK owns this set and a
- *  copy here would rot silently the day it grows a fourth member.
- *  `@v-office/sdk-core` exports the union as `GuestQuoteUnavailableCode`, but
- *  `@v-office/website-sdk` does not re-export it and sdk-core is a transitive
- *  dependency an adopting project does not declare — so `Extract` off the
- *  result type is the reachable spelling. */
-export type QuoteUnavailableCode = Extract<GuestQuoteResult, {
-  status: "unavailable";
-}>["code"];
-/** The two codes that mean "the stay WAS priced, but the rental's rate setup
- *  cannot be resolved to the single multi-rate a booking must be written
- *  against" — a v10 backend-configuration fault the guest has no part in.
- *
- *  `resolveV10MultiRate` matches the priced quote's service lines against the
- *  rental's multi-rate rows for the policy, then tie-breaks on `baseRentRate`,
- *  which only fires when EXACTLY ONE tied row carries it. A rental whose PMS
- *  holds several equivalent base-rent rows per cancellation policy leaves the
- *  tie unbroken, and the SDK reports the quote unavailable rather than guess a
- *  rate — the price alone does not identify which row the booking belongs to.
- *
- *  There is nothing an adopting site can do about the stay itself: it stays
- *  unbookable until the surplus rows are removed in the PMS. What the site owes
- *  the guest is honest copy — never the generic "not available", which asserts
- *  a booking conflict that does not exist. */
-export declare const MULTI_RATE_CODES: readonly ["AmbiguousMultiRate", "UnresolvableMultiRate"];
-/** True when an unavailable quote is a rate-configuration fault rather than a
- *  genuinely unbookable stay. Callers branch the MESSAGE on this and must keep
- *  booking disabled either way (SDK 2.16.0 MIGRATION, "Required Consumer
- *  Work"). */
-export declare function isRateConfigurationFault(code: QuoteUnavailableCode | undefined): boolean;
-export interface QuoteOccupancy {
-  adults: number;
-  children: number;
-  childrenAges?: number[] | undefined;
-  babies: number;
-  pets: number;
-}
-/** Flatten a GuestQuote into the renderable view. Values verbatim.
- *
- * DISCOUNTS: the SDK does not hand us a discount LINE. When the PMS applies a
- * price modifier (Frühbucher/Last-Minute, a voucher, a policy markup) it hangs
- * it off the charge line as `modifiers[]` — label plus signed amount — and puts
- * the pre-modifier figure in `totalBeforeModifiers`, leaving `appliedCharge`
- * already net. Render `appliedCharge` alone (what every adoption did until now)
- * and the saving is invisible: the guest sees only the reduced number and is
- * never told a discount applied.
- *
- * So each modifier becomes its own row, and the line above it switches to
- * `totalBeforeModifiers`. That pairing is not cosmetic — it is what makes the
- * card add up. A deduction row under an `appliedCharge` that has ALREADY been
- * reduced double-counts on sight: the column no longer sums to the total, and a
- * guest checking the arithmetic finds it wrong. Gross line, then the deduction,
- * then the remaining charges: 1.694,00 − 140,00 + 42,70 = 1.596,70.
- *
- * `bookingCardInformation.totalBeforeModifiers` is deliberately NOT rendered.
- * The deduction rows already carry the saving, and a struck-through "was" price
- * would state it a second time — as the one figure on the card that cannot be
- * checked by adding, and as a price claim the customer would have to stand
- * behind. The total stays the single net number.
- */
-export declare function adaptGuestQuote(quote: GuestQuote): QuoteView;
-/** Price a stay for `rentalId`. The caller owns the SDK instance and its
- *  lifecycle — pass a shared one to reuse its queue + cache across the caller's
- *  lifetime. `voucher` re-prices with a code (the PMS decides what it's worth). */
-export declare function fetchQuote(rentalId: string, period: {
-  start: string;
-  end: string;
-}, occupancy: QuoteOccupancy, sdk: WebsiteSdk, locale: Locale, voucher?: string): Promise<QuoteResult>;
-export type QuoteSelectionResult = {
+/** One stay to price. */
+interface QuoteRequest {
+  /** PMS rental id (numeric unit id on v9). */
+  rentalId: string;
+  /** Arrival and departure days. */
+  period: {
+    start: IsoDay;
+    end: IsoDay;
+  };
+  /** The party as the SDK takes it (`occupancyOf`). */
+  occupancy: QuoteOccupancy;
+  /** Language of the PMS strings and formats. */
+  locale: Locale;
+  /** Re-price with a code; the PMS decides what it is worth. */
+  voucher?: string | undefined;
+}
+/** A selection call's answer: a NEW quote, or a refusal with the PMS's reason when it gave one (only
+ *  `UnavailableQuoteCombination` does). Callers keep the previous quote on a refusal. */
+type QuoteSelectionResult = {
   ok: true;
   quote: GuestQuote;
 } | {
   ok: false;
   reason?: string | undefined;
 };
-export declare function addQuoteService(quote: GuestQuote, id: string, sdk: WebsiteSdk): Promise<QuoteSelectionResult>;
-export declare function removeQuoteService(quote: GuestQuote, id: string, sdk: WebsiteSdk): Promise<QuoteSelectionResult>;
-/** Drop every additional-service selection from `quote`.
- *
- *  A fresh quote's selection state is not knowable from the service list. It is
- *  empty by default and carries the PMS's proposed quantities only when the
- *  project sets `shouldAddProposedAdditionalServiceAmount: true` — an SDK
- *  option a component cannot see — and the quote will not say which happened
- *  (`GuestQuote.selections` is behind an unexported symbol). Rather than branch
- *  on something invisible, a caller that needs a known starting point clears
- *  first and steps up from zero with `addQuoteService`. */
-export declare function clearQuoteServices(quote: GuestQuote, sdk: WebsiteSdk): Promise<QuoteSelectionResult>;
-export declare function selectQuotePolicy(quote: GuestQuote, id: string, sdk: WebsiteSdk): Promise<QuoteSelectionResult>;
-/** Select a travel-insurance product (`id`) or none (`null`). Unlike the
- *  service/policy calls the SDK returns the new GuestQuote directly and throws
- *  on failure (unknown id) — normalized here to the same QuoteSelectionResult
- *  the other selection helpers use, so a stale id is a silent no-op the caller
- *  handles by keeping the previous quote.
- *
- *  For a product that needs no traveler data this is the COMPLETE selection:
- *  the premium books with the rental via `booking.book`, which reads the plan
- *  off the quote. A product with `requiresTravelers` needs the pre-contract /
- *  payment / `bookInsurance` steps on top, which the checkout does not
- *  implement — it offers only the products it can complete. */
-export declare function selectQuoteInsurance(quote: GuestQuote, id: string | null, sdk: WebsiteSdk): Promise<QuoteSelectionResult>;
-/**
- * The concrete "free cancellation until" date for ONE policy — DERIVED, not
- * fabricated: the PMS states its rules relatively (`daysBeforeArrival` +
- * `refundPercentage`), so with the chosen arrival in hand the deadline is
- * plain arithmetic (arrival − daysBeforeArrival), the same category of
- * derivation as computing nights from a range.
- *
- * Uses the policy's full-refund (100%) rule. Returns null when the policy has
- * no full-refund rule OR the derived date is already in the past (booking
- * inside the window — advertising a bygone deadline would be wrong).
- */
-/** The policy's full-refund rule, if it has one. The refund figure is the SDK's
- *  own formatted string ("100%"), so this reads it rather than comparing a
- *  number — the one place that pattern is written, because both the derived
- *  deadline and the "is this a refundable rate at all" question depend on it. */
-export declare function fullRefundRule(policy: QuoteCancellationPolicy | undefined): QuotePolicyRule | undefined;
-export declare function policyFreeCancellationUntil(policy: QuoteCancellationPolicy | undefined, arrival: Date): Date | null;
-/** The deadline for the stay as it stands — i.e. of the SELECTED policy.
- *  Kept as its own name because that is what a summary line means: not "some
- *  policy allows this" but "what you have chosen allows this". */
-export declare function freeCancellationUntil(policies: QuoteCancellationPolicy[], arrival: Date): Date | null;
-/** The same stay priced under ONE cancellation policy. `quote` is a real
- *  GuestQuote branched off the base, so the UI can show its card, and hand the
- *  branch on to a later step, without re-quoting the stay. */
-export interface PolicyBranch {
+/** The same stay priced under ONE cancellation policy (the base itself for the selected one). */
+interface PolicyBranch {
+  /** The policy this branch is priced under. */
   id: string;
-  /** The branch quote — the base itself for the already-selected policy. */
+  /** The branch quote (the base itself for the pre-selected policy); it can be booked as is. */
   quote: GuestQuote;
-  /** That quote flattened, so `view.card.total` is THIS policy's real price. */
+  /** That quote flattened: `view.price.total` is THIS policy's real price. */
   view: QuoteView;
 }
-/**
- * Price every selectable cancellation policy off ONE base quote, so a guest can
- * compare the policies by what each actually costs rather than by a percentage.
- *
- * WHY REAL BRANCHES AND NOT ARITHMETIC. `markUpPercentage` looks like enough to
- * compute the alternative price, and it is not: the modifier applies to the
- * RENT, while taxes and fees ride along untouched, so the change it makes to
- * the total is always smaller than the percentage says — and a guest who checks
- * the number against the total would find the site's own figure wrong. The
- * arithmetic is unavailable in any case: every amount the SDK returns is a
- * locale-formatted string, so computing on one means parsing it back, which
- * this file does for no other charge either. What the PMS prices is what the UI
- * shows.
- *
- * `selectCancellationPolicy` does NOT mutate its input — it returns a new quote
- * — so each policy can be branched off the same base and the branches held side
- * by side. Costs one SDK call per policy MINUS one: the already-selected policy
- * is the base quote itself. Sequential, because the API allows 1 req/s.
- *
- * A policy the PMS marks `available: false` is skipped rather than attempted:
- * selecting it would fail by definition, and a burnt request inside a 1 req/s
- * budget delays the ones that can succeed. It simply gets no branch, and the UI
- * renders it as the unselectable row it already is.
- */
-export declare function pricePolicyBranches(base: GuestQuote, sdk: WebsiteSdk): Promise<PolicyBranch[]>;
+/** The two codes that mean "the stay WAS priced, but the rate setup cannot be resolved to the one
+ *  multi-rate a booking is written against" — a PMS configuration fault, never "not available". */
+export declare const MULTI_RATE_CODES: readonly ["AmbiguousMultiRate", "UnresolvableMultiRate"];
+/** Flatten a GuestQuote; values verbatim. Each modifier becomes its own row and the line above it
+ *  switches to `totalBeforeModifiers`, so the column adds up (1.694,00 − 140,00 + 42,70 = 1.596,70).
+ *  Consecutive identical SUB lines whose amount states no figure ("Inklusive", multi-season stays)
+ *  collapse into one; a line with a figure never collapses. */
+type AdaptGuestQuote = (quote: GuestQuote) => QuoteView;
+/** Price a stay (`quote.quote`). The caller owns the SDK; a throw is the caller's to log. */
+type FetchQuote = (sdk: WebsiteSdk, request: QuoteRequest) => Promise<QuoteResult>;
+/** A selection call on a live quote (add, remove, select); a throw is logged and becomes `ok: false`. */
+type SelectOnQuote = (sdk: WebsiteSdk, quote: GuestQuote, id: string) => Promise<QuoteSelectionResult>;
+/** Drop every service selection — the known starting point (see `proposedQuantity`). */
+type ClearQuoteServices = (sdk: WebsiteSdk, quote: GuestQuote) => Promise<QuoteSelectionResult>;
+/** Select an insurance product, or none (`null`). The SDK throws on failure; normalized here. */
+type SelectQuoteInsurance = (sdk: WebsiteSdk, quote: GuestQuote, id: string | null) => Promise<QuoteSelectionResult>;
+/** Which rates `pricePolicyBranches` prices. */
+interface PolicyBranchOptions {
+  /** Only these ids (the rates `offeredPolicies` still offers for the arrival); default every one.
+   *  A withdrawn rate is never shown, so pricing it would only queue behind the 1 req/s limit. */
+  only?: readonly string[];
+}
+/** Every selectable policy priced as its own quote off one base — sequential (the API allows 1 req/s),
+ *  skipping `available: false` and ids outside `only`; the selected one is the base itself; a refused
+ *  branch is omitted (a row without a price, never another rate's total). Real branches, because the
+ *  markup applies to the rent and not to the total. */
+type PricePolicyBranches = (sdk: WebsiteSdk, base: GuestQuote, options?: PolicyBranchOptions) => Promise<PolicyBranch[]>;
+/** True for a rate-configuration fault; the UI branches the MESSAGE on it and keeps booking disabled. */
+type IsRateConfigurationFault = (code: QuoteUnavailableCode | undefined) => boolean;
+/** Pin the presentation order of the breakdown across re-quotes: every selection returns a new quote
+ *  whose lines may come back reordered, and rows that jump read as flakiness. Each block (a charge with
+ *  its sub and discount rows) keeps the position it had when first seen; new blocks append in SDK
+ *  order. `orderMap` is the caller's memory across calls and is updated in place. */
+type StabilizeCardOrder = (view: QuoteView, orderMap: Map<string, number>) => QuoteView;
+/** See {@link AdaptGuestQuote}. */
+export declare const adaptGuestQuote: AdaptGuestQuote;
+/** See {@link FetchQuote}. */
+export declare const fetchQuote: FetchQuote;
+/** See {@link SelectOnQuote}: add one unit of a service. */
+export declare const addQuoteService: SelectOnQuote;
+/** See {@link SelectOnQuote}: remove one unit of a service. */
+export declare const removeQuoteService: SelectOnQuote;
+/** See {@link ClearQuoteServices}. */
+export declare const clearQuoteServices: ClearQuoteServices;
+/** See {@link SelectOnQuote}: price the stay under another cancellation policy. */
+export declare const selectQuotePolicy: SelectOnQuote;
+/** See {@link SelectQuoteInsurance}. */
+export declare const selectQuoteInsurance: SelectQuoteInsurance;
+/** See {@link PricePolicyBranches}. */
+export declare const pricePolicyBranches: PricePolicyBranches;
+/** See {@link IsRateConfigurationFault}. */
+export declare const isRateConfigurationFault: IsRateConfigurationFault;
+/** See {@link StabilizeCardOrder}. */
+export declare const stabilizeCardOrder: StabilizeCardOrder;
+//#endregion
+//#region src/quote/policies.d.ts
+/** What a rate is worth FOR THIS STAY.
+ *  - "refundable": a full-refund deadline still ahead (or no stay picked yet: nothing has lapsed).
+ *  - "expired": it has a full-refund rule and no rule at all can still be met.
+ *  - "other": no full-refund rule, or only a partial rule still reachable. */
+type PolicyStance = "refundable" | "expired" | "other";
+/** What a row is CALLED. A host-created policy keeps its label; the PMS's three built-ins are titled by
+ *  stance, because their names grade the host's strictness and read to a guest as a warning. */
+type PolicyTitle =
+/** The host's own name, verbatim — including a host-made default ("a host named theirs Testrichtlinie"). */
+{
+  kind: "own";
+  label: string;
+} |
+/** A built-in that still refunds in full. */
+{
+  kind: "refundable";
+} |
+/** A built-in whose window has closed for this stay. */
+{
+  kind: "expired";
+} |
+/** A built-in that is neither (unreachable with today's three; never falls back to the name). */
+{
+  kind: "standard";
+};
+/** What a policy MEANS, decided by precedence — one variant, never several:
+ *  deadline (single rule, still ahead) > prose (not an echo of the title, no smuggled built-in name) >
+ *  rules > none; "expired" replaces all of them. */
+type PolicyTerms =
+/** "Free cancellation until {date}": arrival − the 100 % rule's days. */
+{
+  kind: "deadline";
+  date: IsoDay;
+} |
+/** The PMS's own description, verbatim. */
+{
+  kind: "prose";
+  text: string;
+} |
+/** The refund ladder, one line per rule. */
+{
+  kind: "rules";
+  rules: QuotePolicyRule[];
+} |
+/** The refundable window has closed; `daysBeforeArrival` names the lapsed deadline. */
+{
+  kind: "expired";
+  daysBeforeArrival: number;
+} |
+/** Nothing to state (the SDK's minimal `{ id, label, selected }`, or the title already said it). */
+{
+  kind: "none";
+};
+/** One offered rate, ready to render. */
+interface PolicyOption {
+  /** The policy id `choosePolicy` takes. */
+  id: string;
+  /** What the row is called. */
+  title: PolicyTitle;
+  /** The rate the shown price is for. */
+  selected: boolean;
+  /** False: shown, but not selectable for the current combination. */
+  available: boolean;
+  /** The PMS's reason for `available: false`, verbatim, or null. */
+  unavailableReason: string | null;
+  /** This rate's real total from its branch; null while pending, when the branch failed, or when no
+   *  branches were priced. */
+  total: string | null;
+  /** What the rate means for this stay. */
+  terms: PolicyTerms;
+  /** Shown under the terms. `markUp` only when `total` is null — a percentage beside a real total
+   *  invites a check that finds the site wrong (the markup applies to the rent, not the total). */
+  notes: {
+    markUp: string | null;
+    processingFee: string | null;
+  };
+}
+/** Where the guest picks the rate — ONE site decision, the same value on Quote and Booking:
+ *  "rental-page" (default): Quote offers the picker, Booking applies the carried ?policy= and states it;
+ *  "checkout": Quote states the pre-selected rate's terms only, Booking offers the picker. */
+type PolicyChoiceMode = "rental-page" | "checkout";
+/** The policy model of one priced stay. */
+interface PolicyOffer {
+  /** "choice": ≥ 2 offered rates on the surface that picks → a picker (`options` = every offered rate).
+   *  "single": one offered rate there → `freeCancellationUntil` as one sentence, or nothing.
+   *  "terms": the other surface → the applied rate's terms block, no picker (`options` = that rate).
+   *  "none": the quote carries no policies (every v9 hub) → a site's `cancellationNote` may speak. */
+  mode: "choice" | "single" | "terms" | "none";
+  /** The rows to render (see `mode`). */
+  options: PolicyOption[];
+  /** The guest's explicit pick when it is offered; null = the PMS pre-selection. */
+  chosenId: string | null;
+  /** Branch prices are still being fetched. */
+  pricesPending: boolean;
+  /** For "single" and "terms": the shown rate's live free-cancellation day, or null. */
+  freeCancellationUntil: IsoDay | null;
+}
+/** What `describePolicyOffer` takes. */
+interface PolicyOfferInput {
+  /** The quote's policies (unfiltered; the offer rule is applied here). */
+  policies: readonly QuoteCancellationPolicy[];
+  /** The priced branches, or null when none were priced. */
+  branches: readonly PolicyBranch[] | null;
+  /** Branch prices are still being fetched. */
+  pricesPending: boolean;
+  /** The guest's explicit pick, or null. */
+  chosenId: string | null;
+  /** The stay's arrival. */
+  arrival: IsoDay;
+  /** The site's decision where the rate is chosen. */
+  mode: PolicyChoiceMode;
+  /** Which surface asks: the Quote offers the picker in "rental-page" mode, Booking in "checkout" mode. */
+  surface: "quote" | "checkout";
+  /** Default today in the visitor's timezone. */
+  today?: IsoDay;
+}
+/** What `policyTerms` takes. */
+interface PolicyTermsOptions {
+  /** The stay's arrival; absent before a stay is picked (no deadline line then). */
+  arrival?: IsoDay;
+  /** Default today in the visitor's timezone. */
+  today?: IsoDay;
+  /** The row shows this policy's real total. Terms never depend on it — it decides
+   *  `PolicyOption.notes.markUp` — and is accepted so both describe one row with one object. */
+  hasTotal: boolean;
+  /** The row already prints `policyTitle` above the terms: the expired line is then dropped where the
+   *  title was substituted (a built-in), never under a host's own name, which says nothing about refunds. */
+  titled: boolean;
+}
+/** The backend states deadlines in whole days only (`daysBeforeArrival`; the v1 schema carries no hour,
+ *  cut-off or timezone), so no time is ever printed and every comparison is at midnight. */
+export declare const POLICY_DEADLINE_HAS_TIME: false;
+/** The type of `BUILT_IN_POLICY_LABELS` (declared below): the PMS's three built-in policy names
+ *  (SYSTEM_FIRM_14, SYSTEM_STRICT_30, SYSTEM_STRICT_60) in de + en, lowercased — closed, read out of the
+ *  SDK's translation catalogue; a package test re-reads the installed catalogue in both directions. */
+type BuiltInPolicyLabels = ReadonlySet<string>;
+/** True for one of the PMS's built-ins; everything else the host created and named. */
+type IsBuiltInPolicy = (policy: QuoteCancellationPolicy) => boolean;
+/** The rate's stance for a stay arriving on `arrival` (absent: no stay picked → describe the rate). */
+type PolicyStanceOf = (policy: QuoteCancellationPolicy, arrival?: IsoDay, today?: IsoDay) => PolicyStance;
+/** The row title (see `PolicyTitle`). */
+type PolicyTitleOf = (policy: QuoteCancellationPolicy, arrival?: IsoDay, today?: IsoDay) => PolicyTitle;
+/** The terms by precedence (see `PolicyTerms`). */
+type PolicyTermsOf = (policy: QuoteCancellationPolicy, options: PolicyTermsOptions) => PolicyTerms;
+/** The full set minus rates that stopped being a trade: beside a standard rate that can no longer refund
+ *  anything, only rates that still can survive — otherwise the cheaper non-refundable rate is the same
+ *  booking for less. The standard (the row without a markup, else the first; never "selected", which
+ *  moves) always survives. A rule refunding 0 % refunds nothing, however reachable. */
+type OfferedPolicies = (policies: readonly QuoteCancellationPolicy[], arrival?: IsoDay, today?: IsoDay) => QuoteCancellationPolicy[];
+/** Arrival − the 100 % rule's days, if still ahead; else null (never a bygone deadline). */
+type FreeCancellationUntil = (policy: QuoteCancellationPolicy | undefined, arrival: IsoDay, today?: IsoDay) => IsoDay | null;
+/** The policy model of a priced stay for one surface (shared by createQuoteFlow and the checkout). */
+type DescribePolicyOffer = (input: PolicyOfferInput) => PolicyOffer;
+/** Duplicated from the SDK catalogue (`dist/translations/v10/<locale>/core.json`,
+ *  `CancellationPolicy.policyType.option.SYSTEM_*`) because it is not reachable through the public SDK.
+ *  A host-created policy is returned untranslated (measured: byte-identical in de-DE and en-US), a
+ *  second reason this list can only ever match the backend's own. */
+export declare const BUILT_IN_POLICY_LABELS: BuiltInPolicyLabels;
+/** See {@link IsBuiltInPolicy}. */
+export declare const isBuiltInPolicy: IsBuiltInPolicy;
+/** See {@link FreeCancellationUntil}. */
+export declare const freeCancellationUntil: FreeCancellationUntil;
+/** See {@link PolicyStanceOf}. */
+export declare const policyStance: PolicyStanceOf;
+/** See {@link PolicyTitleOf}. */
+export declare const policyTitle: PolicyTitleOf;
+/** See {@link PolicyTermsOf}. */
+export declare const policyTerms: PolicyTermsOf;
+/** See {@link OfferedPolicies}. */
+export declare const offeredPolicies: OfferedPolicies;
+/** See {@link DescribePolicyOffer}. */
+export declare const describePolicyOffer: DescribePolicyOffer;
+//#endregion
+//#region src/quote/events.d.ts
+/** The window event name (`CustomEvent<QuoteEventDetail>`), dispatched once per stay. */
+export declare const QUOTE_EVENT: "voffice:quote";
+/** What happened. "rate-fault": a stay the PMS priced but cannot resolve to one multi-rate
+ *  (`AmbiguousMultiRate` / `UnresolvableMultiRate`) — a configuration fault for site operations
+ *  (SDK 2.16.0 MIGRATION §2), never shown to the guest as "not available". */
+type QuoteEventDetail = {
+  type: "rate-fault";
+  /** PMS rental id. */
+  rentalId: string;
+  /** The stay (`stayKeyOf`: dates + party counts, no names). */
+  stayKey: string;
+  /** The SDK's machine code. */
+  code: QuoteUnavailableCode;
+};
+//#endregion
+//#region src/quote/createQuoteFlow.d.ts
+/** v9 in practice: show the campaign label the search measured for THIS stay.
+ *  "none" (default) · "from-search": read `?offer=`, latch it to the first complete stay after the
+ *  handover (only when that stay is provably the one the search priced), drop it on any edit, never
+ *  re-arm. A label only — never a struck price or a saving (search and quote disagree on discounted
+ *  totals). */
+type CampaignLabelSource = "none" | "from-search";
+/** What an unavailable stay offers beyond the PMS's reason.
+ *  "none" (default) · "next-arrival": the first arrivable day after the chosen start, from the arrival
+ *  map already loaded (no extra request). "other-rentals" is reserved (needs a search runner). */
+type WhenUnavailable = "none" | "next-arrival";
+/** The options a widget brings to its rental's flow (Quote's props). `configure` applies them to a flow
+ *  another island of the rental created first (an occupancy calendar that hydrated earlier). */
+interface QuoteFlowSettings {
+  /** limits (a 20-person house raises adults), childAge (ages outside it are asked again),
+   *  defaultAdults (default 2). */
+  guests?: GuestOptions;
+  /** Default "rental-page". */
+  policyChoice?: PolicyChoiceMode;
+  /** Default "none". */
+  campaignLabels?: CampaignLabelSource;
+  /** Default "none". */
+  whenUnavailable?: WhenUnavailable;
+  /** The site's minimum stay in nights on top of the PMS (see `StayPickerOptions.minStayNights`). */
+  minStayNights?: number;
+}
+/** The flow's options: the picker's, plus the widget's settings, the caps and the hooks. */
+interface QuoteFlowOptions extends StayPickerOptions, QuoteFlowSettings {
+  /** Catalogue capacity (where availability states no caps: v9 before SDK 2.28) and the pets flag. */
+  caps?: Pick<GuestCaps, "maxGuests" | "petsAllowed">;
+  /** Debounce before the auto-quote, coalescing stepper bursts. Default 350. */
+  autoQuoteDelayMs?: number;
+  /** Once per stay on AmbiguousMultiRate / UnresolvableMultiRate. Default: one console.warn. */
+  onEvent?: (detail: QuoteEventDetail) => void;
+}
+/** The answer for the current stay. Every non-idle kind carries the `stayKey` it belongs to, so
+ *  nothing from a superseded stay is ever shown. */
+type QuoteOutcome =
+/** No complete range, no adult, an age missing, or the handover still resolving. */
+{
+  kind: "idle";
+} |
+/** Debounce, the arrival map, the request, or the chosen rate's branch still in flight. */
+{
+  kind: "pending";
+  stayKey: string;
+} |
+/** The price of the shown rate (the guest's pick or the PMS pre-selection). */
+{
+  kind: "priced";
+  stayKey: string;
+  price: PriceView;
+  policies: PolicyOffer;
+  /** The latched search labels while this IS the stay they were measured for, else []. */
+  campaignLabels: string[];
+  /** Carried for custom UIs; the quote surface never renders insurance. */
+  insurance: QuoteInsurance | null;
+} |
+/** NotBookable: the SDK's reason verbatim (possibly multi-line), or null when it states none. */
+{
+  kind: "unavailable";
+  stayKey: string;
+  reason: string | null;
+} |
+/** The days are free but the rate setup is faulty — never say "not available". */
+{
+  kind: "rate-fault";
+  stayKey: string;
+  code: QuoteUnavailableCode;
+} |
+/** Transport failure; only `retry()` refires. */
+{
+  kind: "error";
+  stayKey: string;
+};
+/** What the primary button does now. */
+type QuoteCta =
+/** The handover is not read yet → skeleton. */
+{
+  kind: "resolving";
+} |
+/** Opens the calendar. */
+{
+  kind: "pick-dates";
+} |
+/** Opens the guest picker: an age is missing (the age prices the stay). */
+{
+  kind: "complete-ages";
+} |
+/** "Price loading", disabled. */
+{
+  kind: "pending";
+} |
+/** The checkout link (`checkoutHref`). */
+{
+  kind: "book";
+} |
+/** Unavailable or rate fault: opens the calendar. */
+{
+  kind: "change-dates";
+} |
+/** After an error. */
+{
+  kind: "retry";
+};
+/** The flow's state. */
+interface QuoteFlowState {
+  /** The handover was applied (and a ± window resolved); until then fields show skeletons. */
+  resolved: boolean;
+  /** The calendar's state (`flow.picker.day()` renders the days). */
+  picker: StayPickerState;
+  /** The travelling party (seeded with `defaultAdults`, the handover wins). */
+  party: Party;
+  /** Stepper bounds for this rental (availability caps > catalogue `maxGuests` > limits). */
+  bounds: GuestBounds;
+  /** Every child has an age; no quote runs before. */
+  agesComplete: boolean;
+  /** Dates + party as one string (`stayKeyOf`), or null without a complete range. */
+  stayKey: string | null;
+  /** The answer for the current stay. */
+  outcome: QuoteOutcome;
+  /** What the primary button does now. */
+  cta: QuoteCta;
+  /** The guest's explicit rate; null = the PMS pre-selection. Reset to null when the stay stops
+   *  offering it (an unknown id from a link, a rate withdrawn by `offeredPolicies`, a failed branch). */
+  chosenPolicyId: string | null;
+  /** With `whenUnavailable: "next-arrival"` and an unavailable / rate-fault outcome: the day, or null. */
+  nextArrival: IsoDay | null;
+  /** Incremented by `requestFocus` / `pickArrival`; a UI opens or scrolls to the widget on a change. */
+  focusRequest: number;
+}
+/** The flow: a store plus the widget's actions. */
+interface QuoteFlow extends Store<QuoteFlowState> {
+  /** The underlying picker (day models for the calendar). */
+  readonly picker: StayPicker;
+  /** Replace the widget's settings (absent keys fall back to their defaults). For a widget joining a
+   *  flow another island created; call it before `hydrate`. Before the handover the party is re-seeded
+   *  with the new `defaultAdults`; outside "rental-page" the guest's rate is dropped. */
+  configure(settings: QuoteFlowSettings): void;
+  /** Apply a handover once (`readQuoteHandover(new URLSearchParams(location.search))`); later calls
+   *  are ignored. A ± window is parked until the arrival map lands, then resolved in two stages: the
+   *  first arrivable day that still fits the stay, then the wanted length or the nearest allowed
+   *  departure inside the window. */
+  hydrate(handover: QuoteHandover): void;
+  /** A calendar click (see `StayPicker.select`). */
+  selectDay(iso: IsoDay): void;
+  /** Clear the dates. */
+  resetDates(): void;
+  /** Change the party; clamped to the bounds (a dog cannot be added where pets are not allowed, a
+   *  handed-over one can be lowered and is still sent). */
+  setParty(patch: Partial<Party>): void;
+  /** The guest's rate (null = PMS pre-selection); "rental-page" mode only. Switching costs no request:
+   *  every branch was priced up front. */
+  choosePolicy(id: string | null): void;
+  /** Re-run a quote that failed in transport. */
+  retry(): void;
+  /** From AvailabilityCalendar: set the arrival only, enter the departure phase, request focus. */
+  pickArrival(iso: IsoDay): void;
+  /** Apply `nextArrival` as the new start (departure phase). */
+  takeNextArrival(): void;
+  /** Ask the UI to bring the widget into view. */
+  requestFocus(): void;
+  /** Fetch availability; nothing is quoted before the arrival map answered (ready or failed). */
+  start(): void;
+  /** Stop: timers cleared, late answers dropped. */
+  dispose(): void;
+}
+/** The flow over the caller's SDK, resolved once on the first request (again only after a failed
+ *  resolve) and shared with its picker. Requests: the arrival map, one departure map per chosen start,
+ *  one quote per settled stay, and in "rental-page" mode one branch per further offered rate. */
+type CreateQuoteFlow = (sdk: SdkSource, options: QuoteFlowOptions) => QuoteFlow;
+/** One flow per key across islands (card, bar, an occupancy calendar), ref-counted on `globalThis`. The
+ *  first caller's `create` wins (a widget that joins re-applies its settings with `configure`); the last
+ *  `release` disposes. Userland can subscribe to a rental's flow (a gallery offer pill) without a window
+ *  event. */
+type AcquireQuoteFlow = (key: string, create: () => QuoteFlow) => {
+  readonly flow: QuoteFlow;
+  release(): void;
+};
+/** See {@link CreateQuoteFlow}. */
+export declare const createQuoteFlow: CreateQuoteFlow;
+/** See {@link AcquireQuoteFlow}. */
+export declare const acquireQuoteFlow: AcquireQuoteFlow;
+//#endregion
+//#region src/quote/handover.d.ts
+/** The rental-page keys this surface reads and writes (the funnel contract: search → quote → checkout). */
+export declare const QUOTE_PARAM_KEYS: readonly ["start", "end", "adults", "children", "childrenAges", "babies", "pets", "policy"];
+/** Keys a ± search link adds: resolved into a stay, then stripped. */
+export declare const WINDOW_PARAM_KEYS: readonly ["minNights", "maxNights", "flex"];
+/** The repeatable campaign label a search card hands over — a label only, never a figure. */
+export declare const CAMPAIGN_PARAM: "offer";
+/** What a rental-page URL says. Invalid values degrade to absent, never to an error. */
+interface QuoteHandover {
+  /** A valid day, or null. */
+  start: IsoDay | null;
+  /** A valid day after `start`, or null. */
+  end: IsoDay | null;
+  /** A ± window: start/end are its bounds and the stay length is pinned. Present only with start + end
+   *  and a night pair shorter than the window; nights = `maxNights` (equal to `minNights` on a pinned
+   *  pair; a range min < max takes the upper bound, the length the hub prices). */
+  window: {
+    nights: number;
+  } | null;
+  /** Null when the URL carries no party key at all (the flow then seeds `defaultAdults`). Read with
+   *  `readParty`: `petsCount` (legacy search links) wins over `pets`. */
+  party: Partial<Party> | null;
+  /** An explicit rate from a shared link; checked against the stay's offered rates later. */
+  policyId: string | null;
+  /** Campaign labels: trimmed, distinct, at most four (a crafted URL cannot paste a list into the box). */
+  campaignLabels: string[];
+}
+/** Read a handover. */
+type ReadQuoteHandover = (params: URLSearchParams) => QuoteHandover;
+/** The URL after a state change: quote keys set or deleted (start always, end only when complete,
+ *  adults even at the default, zero counts omitted, `policy` only for an explicit choice — the absence
+ *  IS the deferral to the PMS pre-selection), the legacy `petsCount` and the window keys stripped once
+ *  resolved, campaign labels kept only while latched to the priced stay. Every other key keeps its value
+ *  and position. Before the handover resolved, `current` is returned unchanged (the first write must not
+ *  clobber what is still being read). Returns a new object; equal output = leave the URL alone. */
+type WriteQuoteParams = (current: URLSearchParams, state: QuoteFlowState) => URLSearchParams;
+/** `path?<stay>` from STATE (never from location), so the link is the priced stay: start, end, the party
+ *  (dogs as `pets`), `policy` only when explicit, `kind=option` for an option booking. Null without a
+ *  complete, priced stay. */
+type CheckoutHref = (path: string, state: QuoteFlowState, kind?: "booking" | "option") => string | null;
+/** The stay alone as a query string without "?" (dates + party; for an enquiry link). Null without a
+ *  complete range. */
+type StayQuery = (state: QuoteFlowState) => string | null;
+/** See {@link ReadQuoteHandover}. */
+export declare const readQuoteHandover: ReadQuoteHandover;
+/** See {@link WriteQuoteParams}. */
+export declare const writeQuoteParams: WriteQuoteParams;
+/** See {@link CheckoutHref}. */
+export declare const checkoutHref: CheckoutHref;
+/** See {@link StayQuery}. */
+export declare const stayQuery: StayQuery;
+//#endregion
+//#region src/checkout/stay.d.ts
+/** A complete stay: arrival and departure (local calendar days, `end` after `start`) and the party.
+ *  Serializable on purpose: it travels through the URL handover and into the return snapshot. */
+interface Stay {
+  /** Arrival. */
+  readonly start: IsoDay;
+  /** Departure (after `start`). */
+  readonly end: IsoDay;
+  /** The travelling party. */
+  readonly party: Party;
+}
+//#endregion
+//#region src/checkout/handover.d.ts
+/** A confirmed booking, or a non-binding option (SDK `kind: "OPTION"`, v10 and v9). */
+type BookingKind = "booking" | "option";
+/** What the checkout URL says. */
+interface CheckoutHandover {
+  /** From `start`, `end` and the party keys; null when the dates are missing or invalid (the
+   *  checkout shows its missing-stay card). */
+  stay: Stay | null;
+  /** `?policy=`: the rate chosen on the rental page. A seed: the flow applies it only while the
+   *  policy rule still offers it for this arrival. Null = the PMS pre-selection. */
+  policyId: string | null;
+  /** `?kind=option`, honoured only with `allowOption`; otherwise "booking". */
+  kind: BookingKind;
+  /** `?return=1`: a payment provider sent the guest back to this page (sites that return to the
+   *  checkout itself; the package's own return page is a separate route). */
+  paymentReturn: boolean;
+}
+/** How the checkout reads its URL. */
+interface CheckoutHandoverOptions {
+  /** Adults assumed when the URL has dates but no adults. Default 2 (the quote's default). */
+  defaultAdults?: number | undefined;
+  /** Accept `?kind=option`. Default false. */
+  allowOption?: boolean | undefined;
+}
+/** Parse the checkout URL (pass `location.search`). Pure. Reads `pets` and the legacy `petsCount`;
+ *  `childrenAges` aligns to `children` (a missing age is null, and blocks booking later). */
+type ReadCheckoutHandover = (search: string, options?: CheckoutHandoverOptions) => CheckoutHandover;
+/** The query string (no leading "?") for `history.replaceState` after an edit: the stay (pets as
+ *  `pets`), an explicit policy only (never today's pre-selection, which would pin it), `kind=option`
+ *  for an option. Every other parameter in `current` (tracking, site keys) is preserved after them. */
+type CheckoutSearch = (input: {
+  stay: Stay | null;
+  policyId: string | null;
+  kind: BookingKind;
+}, current?: string) => string;
+/** See {@link ReadCheckoutHandover}. */
+export declare const readCheckoutHandover: ReadCheckoutHandover;
+/** See {@link CheckoutSearch}. */
+export declare const checkoutSearch: CheckoutSearch;
 //#endregion
-//#region src/booking.d.ts
-/** Where the payment provider sends the guest back after an online payment
- *  (relative — the SDK/PSP resolves it against the site origin). */
-export declare const CHECKOUT_RETURN_PATH = "/buchen/bestaetigung";
-/** The checkout form's flat contact fields (the UI shape). `toBookingContact`
- *  folds them into the SDK's nested BookingContact. */
-export interface BookingContactForm {
+//#region src/checkout/booking.d.ts
+/** The guest's contact as the guest form produces it; folded into the SDK's nested contact. */
+interface BookingContact {
+  /** Given name. */
   forename: string;
+  /** Family name. */
   surname: string;
-  /** Anrede ("Frau" / "Herr"); omitted when the guest picks none. */
-  title?: string | undefined;
+  /** A `SALUTATION_WIRE_VALUES` value; omitted when none was chosen. */
+  title?: string;
+  /** Street (with the number unless the PMS splits it into `housenumber`). */
   street: string;
-  housenumber?: string | undefined;
+  /** House number, where the form asks it separately. */
+  housenumber?: string;
+  /** Postal code. */
   postalcode: string;
+  /** Town. */
   city: string;
-  /** ISO 3166-1 alpha-2, e.g. "DE". */
-  countryCode: string;
+  /** ISO country code. */
+  countryCode: CountryCode;
+  /** Email address (the confirmation goes there). */
   email: string;
-  phone?: string | undefined;
-  note?: string | undefined;
+  /** Normalized `+CC …` (the booking endpoint accepts nothing else). */
+  phone?: string;
+  /** The guest's message to the host. */
+  note?: string;
 }
-export interface PaymentLine {
+/** One line of a payment entry, verbatim. */
+interface PaymentLine {
+  /** The line's label, verbatim. */
   label: string;
+  /** The line's formatted amount, verbatim. */
   amount: string;
 }
-/** One payment entry, verbatim — a contractual step (Anzahlung / Restzahlung /
- *  Rate / Kaution) or a way to settle the whole outstanding balance. */
-export interface PaymentScheduleView {
-  /** SDK's stable kind, for programmatic behaviour ONLY. Everything the guest
-   *  reads comes from `label`: the SDK translates it, and a v10 installment is
-   *  not automatically a v9 prepayment. */
+/** One payment entry, verbatim from the PMS: a contractual step, or a way to settle the whole
+ *  balance at once (`full_amount`). */
+interface PaymentScheduleView {
+  /** For behaviour only; the guest reads `label` (a v10 installment is not a v9 prepayment). */
   kind: BookingPaymentScheduleKind | "full_amount";
+  /** The entry's label, verbatim ("Anzahlung", "Restzahlung"). */
   label: string;
-  /** Complete translated phrase, e.g. "Zahlbar bis zum 6. Februar 2027".
-   *  Render as-is — never parse it, never prefix another due-date label. It
-   *  stopped being a bare date in website-sdk 2.13.0, and it was never reliably
-   *  ISO before that either. */
-  dueOn?: string | undefined;
-  /** Where the payment happens, translated (v10 supplies it when the backend
-   *  states a payment location). Same rule: render, don't reformat. */
-  paymentAt?: string | undefined;
-  lines: PaymentLine[];
+  /** A complete sentence ("Zahlbar bis zum 6. Februar 2027"): render, never parse or prefix. */
+  dueOn?: string;
+  /** Where the payment happens (v10, when the backend states it). */
+  paymentAt?: string;
+  /** The entry's line items. */
+  lines: readonly PaymentLine[];
+  /** The entry's formatted amount, verbatim. */
   amount: string;
-  /** The PMS's own payment options — the SDK union (bank_transfer / redirect /
-   *  form_post / stripe_checkout), untouched. **EMPTY means informational:**
-   *  the SDK cannot perform this payment right now (a future step, on-site, or
-   *  external), so the card must not offer a button for it. */
-  options: BookingPaymentOption[];
-}
-/** A travel-insurance premium still to be settled WITH THE INSURER, from
- *  `book().insurancePaymentOptions` — label and URL verbatim. Deliberately not
- *  a `PaymentScheduleView`: those are the PMS's own steps, owed to the site's
- *  operator and payable through the SDK. This one is a different contract with
- *  a different recipient, and it leaves the site entirely. */
-export interface InsurancePaymentLink {
+  /** Empty = informational (a future, on-site or external step): no button for it. */
+  options: readonly BookingPaymentOption[];
+}
+/** An insurance premium owed to the INSURER (`external_url`), never part of the schedules: a
+ *  different contract with a different recipient, paid off the site. */
+interface InsurancePaymentLink {
+  /** The insurer's label for the payment. */
   label: string;
+  /** The insurer's payment page. */
   url: string;
-  description?: string | undefined;
+  /** The insurer's line about it, when stated. */
+  description?: string;
 }
-export interface BookingConfirmation {
+/** The inline confirmation after `book()`. */
+interface BookingConfirmation {
+  /** A booking or an option. */
+  kind: BookingKind;
+  /** The PMS booking number, verbatim. */
   bookingNumber: string;
-  /** The contractual steps, in backend order — what the guest owes and when. */
-  schedules: PaymentScheduleView[];
-  /** Ways to settle the COMPLETE outstanding balance at once (kind
-   *  `full_amount`), an ALTERNATIVE to the schedule above rather than an
-   *  addition to it. Kept apart because summing the two would double-count, and
-   *  because a synthesized alternative carries no deadline of its own — the
-   *  schedule's steps are where the dates live. */
-  alternatives: PaymentScheduleView[];
-  /** Empty unless insurance was actually booked AND the insurer returned a
-   *  payment page for it. Kept out of `schedules` and `alternatives` on
-   *  purpose: the premium is in neither, so a card that listed it among them
-   *  would misstate what is owed to whom (CONTRACT.md, "Travel insurance"). */
-  insurancePayments: InsurancePaymentLink[];
+  /** The contractual steps, in backend order. */
+  schedules: readonly PaymentScheduleView[];
+  /** Ways to settle the whole balance at once: an ALTERNATIVE to `schedules`, never added to it. */
+  alternatives: readonly PaymentScheduleView[];
+  /** Empty unless insurance was booked and the insurer returned a payment page. */
+  insurancePayments: readonly InsurancePaymentLink[];
+  /** True when any option in `schedules` or `alternatives` can be performed in the browser. */
+  payable: boolean;
 }
-/**
- * Create the booking. `quote` MUST be the live GuestQuote instance (with any
- * service/policy selections applied). USER-initiated only — this reserves for
- * real. Throws on transport/backend errors (the caller renders an honest
- * retry message; nothing was necessarily booked when it throws).
- */
-export declare function submitBooking(quote: GuestQuote, contact: BookingContactForm, sdk: WebsiteSdk, returnPath?: string): Promise<BookingConfirmation>;
-/** True for the option kinds `submitPaymentOption` can perform in-browser
- *  (redirect / form_post / stripe_checkout). Bank transfer is display-only. */
-export declare function isSubmittableOption(option: BookingPaymentOption): option is SubmittableBookingPaymentOption;
-/** Perform an online payment option (redirects the browser to the PSP).
- *  USER-initiated only.
- *
- *  Logged on failure, and this is the worst place in the flow to lose a reason:
- *  by the time a payment option is on screen THE RESERVATION ALREADY EXISTS
- *  (the SDK's `booking.md` says as much), so a failure here is an unpaid
- *  booking, not a failed one. The checkout's catch discards the error entirely
- *  — `.catch(() => setPayError(true))` — so without this a guest who cannot
- *  pay leaves no trace at all, on a booking someone now has to chase. */
-export declare function payWithOption(option: SubmittableBookingPaymentOption, sdk: WebsiteSdk): Promise<void>;
-//#endregion
-//#region src/booking-snapshot.d.ts
-/** Rental identity, parked by the checkout page (which has it from SSR) and
- *  folded into the snapshot at book time — the SDK seam that writes the
- *  snapshot never sees a rental name or a link. */
-export declare const CHECKOUT_CONTEXT_KEY = "voffice:checkout-context";
-/** The finished record `/buchen/bestaetigung` reads. */
-export declare const BOOKING_SNAPSHOT_KEY = "voffice:booking-return";
-/** One gallery image, in the SDK's own shape (`RentalGalleryImage` minus the
- *  fields this page does not render). Stored so the confirmation can show the
- *  unit rather than describe it — the guest booked a place, not a table. */
-export interface SnapshotImage {
-  src: string;
-  srcset?: string | undefined;
-  alt: string;
+/** What `submitBooking` needs besides the quote and the contact. */
+interface SubmitBookingOptions {
+  /** Where the payment provider returns to, relative to the site origin. The site's route. */
+  returnPath: string;
+  /** Default "booking". */
+  kind?: BookingKind | undefined;
+  /** The transfer account holder when the PMS sends none (v9 hub): the operator's name. The SDK never
+   *  substitutes another name (it leaves the row out); this puts the operator back, because the guest
+   *  needs the holder for the bank's payee check. */
+  bankHolderFallback?: string | undefined;
+  /** The stay being booked, for the payment-return snapshot. */
+  stay: Stay;
 }
-export interface CheckoutContext {
-  rentalName: string;
-  location?: string | undefined;
-  href?: string | undefined;
-  /** Capped at the same five the checkout's own summary strip shows. */
-  images?: SnapshotImage[] | undefined;
-}
-export interface BookingSnapshotGuests {
-  adults: number;
-  children: number;
-  babies: number;
-  pets: number;
-}
-/** Every field but `bookingNumber` self-hides when absent — the return page
- *  renders a row only for what it actually has, never an empty shell
- *  (`DATA_SCHEMA.md`: "Optional field gates optional UI"). */
-export interface BookingSnapshot {
-  bookingNumber: string;
-  rentalName?: string | undefined;
-  location?: string | undefined;
-  href?: string | undefined;
-  images?: SnapshotImage[] | undefined;
-  /** `YYYY-MM-DD` — the vocabulary the whole funnel already carries. */
-  start?: string | undefined;
-  end?: string | undefined;
-  guests?: BookingSnapshotGuests | undefined;
-  /** The SDK's own formatted total, verbatim. Never re-derived, never summed. */
-  total?: string | undefined;
-}
-/** Park the rental's identity for the return page. Called by the checkout page
- *  on load — it is the last place in the flow that knows the rental by name. */
-export declare function saveCheckoutContext(context: CheckoutContext): void;
-/**
- * Write the return page's record. Called by `submitBooking` the moment the
- * reservation exists — EARLIER than the SDK's "before submitting a payment
- * option", because that is when the booking number is born, and a guest who
- * settles by bank transfer never leaves the checkout at all.
- *
- * Never throws. The snapshot is a nicety; the booking is not.
- */
-export declare function saveBookingSnapshot(bookingNumber: string, quote: GuestQuote): void;
+/** ⚠ USER-initiated only: reserves for real. `quote` must be the live instance with every selection
+ *  applied. Logs the SDK's cause and rethrows (nothing is necessarily booked when it throws). Writes
+ *  the payment-return snapshot the moment the booking number exists (a bank-transfer guest never
+ *  leaves the checkout, so this is the only place it can be written). */
+type SubmitBooking = (sdk: WebsiteSdk, quote: GuestQuote, contact: BookingContact, options: SubmitBookingOptions) => Promise<BookingConfirmation>;
+/** Every kind but `bank_transfer` (display-only details). */
+type IsSubmittableOption = (option: BookingPaymentOption) => option is SubmittableBookingPaymentOption;
+/** ⚠ USER-initiated only: redirects (or form-posts) to the payment provider. By then the reservation
+ *  EXISTS, so a failure is an unpaid booking someone has to chase: logged before rethrowing. */
+type PayWithOption = (sdk: WebsiteSdk, option: SubmittableBookingPaymentOption) => Promise<void>;
+/** See {@link SubmitBooking}. */
+export declare const submitBooking: SubmitBooking;
+/** See {@link IsSubmittableOption}. */
+export declare const isSubmittableOption: IsSubmittableOption;
+/** See {@link PayWithOption}. */
+export declare const payWithOption: PayWithOption;
+//#endregion
+//#region src/checkout/events.d.ts
+/** The window CustomEvent name. Renaming it is a major. */
+export declare const CHECKOUT_EVENT: "voffice:checkout";
+/** What `CHECKOUT_EVENT` carries; never personal data. */
+type CheckoutEventDetail =
+/** A PMS rate-configuration fault (AmbiguousMultiRate / UnresolvableMultiRate): the stay is free,
+ *  only the rate cannot be resolved. Route it to monitoring. Once per stay. The same `type` as
+ *  `voffice:quote`'s, so one listener serves both surfaces. */
+{
+  readonly type: "rate-fault";
+  readonly rentalId: string;
+  readonly code: QuoteUnavailableCode;
+} |
+/** `book()` succeeded. `payable` is false when nothing can be paid online (bank transfer only): a
+ *  site may then send the guest to its return page itself. */
+{
+  readonly type: "booked";
+  readonly rentalId: string;
+  readonly bookingNumber: string;
+  readonly kind: BookingKind;
+  readonly payable: boolean;
+} |
+/** The guest pressed a payment option; the browser is about to leave for the provider. */
+{
+  readonly type: "payment-started";
+  readonly bookingNumber: string;
+  readonly method: BookingPaymentOption["kind"];
+};
 //#endregion
 //#region src/checkout/insurance.d.ts
-/** The plan's documents as the checkout treats them: what it lists, what the
- *  guest must open, and what makes a plan sellable at all read the SAME list,
- *  so a hidden document can never end up required-but-unlisted (which would be
- *  a gate the guest cannot close). */
-export declare function shownInsuranceResources(option: QuoteInsuranceOption): {
-  label: string;
-  url: string;
-}[];
-/** The insurance products a checkout can actually complete. Two gates, and
- *  this filter is where the layer's capability is declared — a site that adds a
- *  missing flow adds it HERE, upstream, never in its own copy.
- *
- *  1. **Technical.** Products that select with the id alone and book WITH the
- *     rental booking. One that demands per-traveler data first (traveler forms,
- *     pre-contract, SEPA mandate, a post-booking insurance call) needs a flow
- *     this layer does not implement — offering it would dead-end the guest.
- *
- *  2. **Legal.** The product must carry its `resources`, the insurer's
- *     pre-contractual documents (see "Mandatory pre-contractual documents"
- *     below for which duties they discharge). A product the feed sends WITHOUT
- *     them cannot be concluded lawfully here, so it self-hides rather than
- *     being sold undocumented — the same rule as (1), applied to a legal
- *     precondition instead of a technical one. */
-export declare function selectableInsuranceOptions(insurance: QuoteInsurance): QuoteInsuranceOption[];
-/** The selected plan, but only when it is one the guest could actually pick
- *  here — so no price row can name a product the section above never showed. */
-export declare function selectedInsuranceOption(insurance: QuoteInsurance | undefined): QuoteInsuranceOption | undefined;
-/** The identity of an insurance PRODUCT, as opposed to the id of one priced
- *  variant of it.
- *
- *  An insurer may band its tariffs by trip value, and then a plan id is not the
- *  product — it is the product AT one price. The same tariff comes back under a
- *  new id and a new premium the moment the total crosses a band. URV is the
- *  observed case: "RRV ohne SB Deutschland" is `RROR0625` at 56,00 € up to
- *  roughly 1.250 €, `RROR0725` at 65,00 € above that, `RROR0825` at 74,00 €
- *  above that again. Every extra, every policy markup and every stay change can
- *  cross a band, and each of them re-prices the quote — which is what makes the
- *  SDK re-fetch the insurer's plan list against the new total.
- *
- *  The label is what survives that: the same string in every band, and the name
- *  the guest actually chose, since it is what the radio shows. */
-export declare function insuranceProductKey(option: QuoteInsuranceOption): string;
-/** The plan id to re-apply onto a re-priced quote, or null when there is
- *  nothing to do — no choice, already applied, or a product this feed no longer
- *  offers as a selectable one. The last case is why the feed is checked rather
- *  than the call simply attempted: a doomed selection would spend one of the
- *  rate-limited requests to be refused, and the guest ends up on "keine
- *  Versicherung" either way.
- *
- *  Matched by id first, then by product (see insuranceProductKey). That
- *  fallback is what keeps a banded re-price from silently un-selecting
- *  insurance the feed still sells: the SDK carries a selection across its
- *  refresh only on an exact id match, so a renamed-but-identical tariff reads
- *  to it as a plan that vanished, and a guest who only added a towel package
- *  lands back on "keine Versicherung". Re-applying picks the SAME product at
- *  its new premium — the one they would in fact be buying — and that premium is
- *  on screen in the radio, in the summary rail and above the submit button, so
- *  nothing about the change is hidden.
- *
- *  Checked against the SELECTABLE options, not the raw list: a plan the fresh
- *  feed carries without its documents (or newly demanding traveler data) is one
- *  the section no longer shows, so re-applying it would leave the quote
- *  carrying an insurance the page neither displays nor can take a document
- *  confirmation for. */
-export declare function insuranceIdToReapply(fresh: QuoteView, wanted: QuoteInsuranceOption | undefined): string | null;
-/** Progress through the document step. Held by the orchestration hook because
- *  the submit button, a card away, is gated on it. */
+/** Progress through the document step (held by the flow: the order button, a section away, is gated
+ *  on it). */
 interface InsuranceDocsState {
-  /** URLs opened so far — keyed by URL, not by plan. Plans routinely share
-   *  every file but the IPID, and having received an identical document does
-   *  not un-happen when the guest switches tariff. Keying by URL also survives
-   *  a re-quote, which returns fresh option objects for the same product. */
+  /** URLs opened so far, keyed by URL rather than by plan: plans routinely share every file but the
+   *  IPID, a document received does not un-happen when the guest switches tariff, and a URL survives
+   *  a re-quote that returns fresh option objects for the same product. */
   opened: ReadonlySet<string>;
-  /** Product whose documents the guest confirmed receiving (keyed by
-   *  insuranceProductKey, not by plan id); null = none yet. Product-bound on
-   *  purpose, so a tariff switch demands a fresh acknowledgement while the
-   *  opened files above carry over. By PRODUCT rather than by plan for the same
-   *  reason the selection is carried by product: a banded re-price hands back
-   *  the identical documents under a new plan id, and making the guest re-tick
-   *  a box for files they already have — because a towel package moved the
-   *  total — would be friction with nothing behind it. */
+  /** The product whose documents the guest confirmed receiving (`insuranceProductKey`), or null.
+   *  Product-bound, so another tariff demands a fresh acknowledgement while opened files carry over;
+   *  by product rather than plan id, because a banded re-price hands back identical documents under
+   *  a new id and re-ticking for files the guest already has would be friction with nothing behind it. */
   confirmedProduct: string | null;
 }
+/** Nothing opened, nothing confirmed. */
 export declare const NO_INSURANCE_DOCS: InsuranceDocsState;
-/** True while a chosen plan's document step is unfinished. No plan chosen (or
- *  "keine Versicherung") is never blocking — the duty attaches to the insurance
+/** The documents shown for a product: what the checkout lists, what the guest must open and what
+ *  makes a plan sellable read this ONE list, so a hidden document can never be required-but-unlisted
+ *  (a gate the guest could not close). Only the GDV consent is excluded, matched by URL (see below). */
+type ShownInsuranceResources = (option: QuoteInsuranceOption) => NonNullable<QuoteInsuranceOption["resources"]>;
+/** The products a checkout can complete. Technical: no per-traveler data (forms, pre-contract, SEPA
+ *  mandate, a post-booking insurance call is a flow this layer does not run). Legal: at least one
+ *  shown pre-contractual document (a product sent without them cannot be concluded lawfully here, so
+ *  it self-hides rather than being sold undocumented). */
+type SelectableInsuranceOptions = (insurance: QuoteInsurance) => QuoteInsuranceOption[];
+/** The selected plan, but only when the guest could pick it here: no price row can name a product
+ *  the section never showed. */
+type SelectedInsuranceOption = (insurance: QuoteInsurance | undefined) => QuoteInsuranceOption | undefined;
+/** The identity of a PRODUCT, not of one priced variant of it. An insurer may band its tariffs by
+ *  trip value: the same tariff returns under a new id and premium once the total crosses a band (one
+ *  insurer: 56,00 € up to about 1.250 €, 65,00 € above, 74,00 € above that). The label survives a
+ *  band change, and it is the name the guest chose. */
+type InsuranceProductKey = (option: QuoteInsuranceOption) => string;
+/** After a re-quote: the plan id to re-apply, or undefined (nothing chosen, already applied, or a
+ *  product the fresh feed no longer offers as selectable). Matched by id, then by product, because
+ *  the SDK carries a selection across its refresh only on an exact id: a renamed-but-identical
+ *  tariff would otherwise land a guest who only added a towel package back on "no insurance". The
+ *  new premium is on screen in the radio, the summary and above the button, so nothing is hidden. */
+type InsuranceIdToReapply = (fresh: QuoteView, wanted: QuoteInsuranceOption | undefined) => string | undefined;
+/** True while a chosen plan's document step is unfinished: every shown document opened AND the
+ *  product confirmed. No plan chosen is never blocking: the duty attaches to the insurance
  *  contract, not to the stay. */
-export declare function insuranceDocsPending(option: QuoteInsuranceOption | undefined, docs: InsuranceDocsState): boolean;
-//#endregion
-//#region src/checkout/stay.d.ts
-interface Stay {
-  start: Date;
-  end: Date;
-  adults: number;
-  children: number;
-  childrenAges: number[];
-  babies: number;
-  pets: number;
-}
-/** Date → `YYYY-MM-DD` in LOCAL time — the vocabulary the URL handover and the
- *  SDK both use. Local on purpose (matches date-fns `format(date,
- *  "yyyy-MM-dd")`, which the sites' own lib/dates.ts uses): a calendar day
- *  picked in the browser must not shift across midnight UTC. */
-export declare function isoDate(date: Date): string;
-export declare function occupancyOf(stay: Stay): QuoteOccupancy;
-/** The identity of a stay for "is the shown price still the shown stay"
- *  comparisons — every field that changes the quote, in one string. */
-export declare function stayKeyOf(stay: Stay): string;
-/** The stay as URL search params (`start`/`end`/`adults`/… — the same
- *  vocabulary the rental page reads + writes). */
-export declare function stayParams(stay: Stay): string;
+type InsuranceDocsPending = (option: QuoteInsuranceOption | undefined, docs: InsuranceDocsState) => boolean;
+/** See {@link ShownInsuranceResources}. */
+export declare const shownInsuranceResources: ShownInsuranceResources;
+/** See {@link SelectableInsuranceOptions}. */
+export declare const selectableInsuranceOptions: SelectableInsuranceOptions;
+/** See {@link SelectedInsuranceOption}. */
+export declare const selectedInsuranceOption: SelectedInsuranceOption;
+/** See {@link InsuranceProductKey}. */
+export declare const insuranceProductKey: InsuranceProductKey;
+/** See {@link InsuranceIdToReapply}. */
+export declare const insuranceIdToReapply: InsuranceIdToReapply;
+/** See {@link InsuranceDocsPending}. */
+export declare const insuranceDocsPending: InsuranceDocsPending;
 //#endregion
-//#region src/checkout/createCheckoutFlow.d.ts
-/**
- * The checkout's orchestration — everything between "a complete stay is in
- * hand" and "the guest is booked and paying", with no markup and no framework.
- *
- * The flow owns the quote lifecycle (initial load, re-quote on stay change,
- * supersession), the selection mutations (extras / insurance / voucher /
- * policy re-apply), the § 7 VVG document gate, booking submit and payment —
- * the parts that must be correct on every site and update mechanically. The
- * UI owns stay EDITING (calendar, guest panel, URL read/write), copy, and
- * every pixel. A UI subscribes to `subscribe`, reads `getState`, calls the
- * actions, and feeds stay/policy changes through `update` (React: one
- * useSyncExternalStore — see the README).
- *
- * ONE flow instance owns the whole thing because the live `GuestQuote` that
- * `booking.book` requires is not serializable across a navigation: the
- * consumer re-quotes from the URL handover on mount and the flow keeps the
- * instance in memory through extras / policy / voucher selections until
- * book().
- *
- * ⚠ `book()` creates a REAL booking; `pay()` starts a REAL payment. Both are
- * strictly user-initiated — never automate them.
- */
-type CheckoutPhase = {
-  kind: "loading";
-} | {
-  kind: "ready";
-} | {
-  kind: "unavailable";
-  reason: string;
-} | {
-  kind: "error";
+//#region src/checkout/payment-return.d.ts
+/** Storage keys, unchanged from the kits, so no guest's return breaks on the switch. */
+export declare const CHECKOUT_CONTEXT_KEY: "voffice:checkout-context";
+export declare const BOOKING_SNAPSHOT_KEY: "voffice:booking-return";
+/** One gallery image, in the SDK's own shape minus what the page does not render. */
+interface SnapshotImage {
+  /** The image URL. */
+  src: string;
+  /** Responsive candidates. */
+  srcset?: string;
+  /** The alternative text. */
+  alt: string;
+}
+/** The rental identity the checkout parks for the return page (it has it from the build). */
+interface CheckoutContext {
+  /** The booked rental's name. */
+  rentalName: string;
+  /** The rental's location line. */
+  location?: string;
+  /** The rental page. */
+  href?: string;
+  /** At most five are kept (the checkout's own strip). */
+  images?: readonly SnapshotImage[];
+}
+/** What the return page renders. Every field but `bookingNumber` and `kind` self-hides when absent. */
+interface BookingSnapshot {
+  /** The PMS booking number. */
+  bookingNumber: string;
+  /** A booking or an option. */
+  kind: BookingKind;
+  /** The booked rental's name. */
+  rentalName?: string;
+  /** The rental's location line. */
+  location?: string;
+  /** The rental page. */
+  href?: string;
+  /** The rental's photos (at most five). */
+  images?: readonly SnapshotImage[];
+  /** Arrival. */
+  start?: IsoDay;
+  /** Departure. */
+  end?: IsoDay;
+  /** The booked party's counts (no names: no personal data is parked). */
+  guests?: {
+    adults: number;
+    children: number;
+    babies: number;
+    pets: number;
+  };
+  /** The PMS's formatted total, verbatim; never re-derived. */
+  total?: string;
+}
+/** How the return page was reached. */
+type PaymentReturn =
+/** This tab booked: the snapshot proves it. */
+{
+  state: "booked";
+  snapshot: BookingSnapshot;
+  paymentCancelled: boolean;
+} |
+/** A provider return without a snapshot (another tab, storage refused). */
+{
+  state: "returned";
+  paymentCancelled: boolean;
+} |
+/** Nobody booked: a bare URL, or tracking parameters only. */
+{
+  state: "none";
 };
-/** The user-facing strings the flow itself needs — the reasons it reports when
- *  the backend gives none, or gives one that would be a false statement. Copy,
- *  so it stays per-site. */
-interface CheckoutFlowMessages {
-  /** Shown INSTEAD of the SDK's localized unavailability reason when the quote
-   *  failed on a rate-configuration fault (AmbiguousMultiRate /
-   *  UnresolvableMultiRate) — the stay is free; only the price cannot be
-   *  resolved, so the availability wording would be a false statement. */
+/** Park the rental identity for the return page (the flow calls it on `start()`). Never throws.
+ *  Default storage `browserStorage("session")`; null = nothing is stored. */
+type SaveCheckoutContext = (context: CheckoutContext, storage?: StorageLike | null) => void;
+/** Classify the return page's URL (pass `location.search`). The snapshot comes first; without one,
+ *  any parameter that is not tracking (`isTrackingParam`) counts as a provider return; a bare or
+ *  tracking-only URL is "none". `paymentCancelled` is Stripe's `payment=stripe&cancel=true`. Fails
+ *  soft: an unreadable store reads as no snapshot. */
+type ReadPaymentReturn = (search: string, storage?: StorageLike | null) => PaymentReturn;
+/** See {@link SaveCheckoutContext}. */
+export declare const saveCheckoutContext: SaveCheckoutContext;
+/** See {@link ReadPaymentReturn}. */
+export declare const readPaymentReturn: ReadPaymentReturn;
+//#endregion
+//#region src/checkout/flow.d.ts
+/** The sentences the flow itself reports. Copy: always passed in (the components' merged
+ *  `CheckoutCopy` satisfies it). */
+interface CheckoutMessages {
+  /** Replaces the SDK reason on a rate-configuration fault: the stay is free, only its rate cannot
+   *  be resolved, so the availability sentence would be false. */
   rateFault: string;
-  /** Fallback when an unavailable result carries no reason of its own. */
+  /** When an unavailable answer carries no reason of its own. */
   unavailable: string;
-  /** Inline issue line when a RE-quote (not the initial load) failed on transport. */
+  /** A re-quote failed on transport (retry offered). */
   quoteRefreshFailed: string;
-  /** Voucher could not be applied at all (transport / stay unavailable). */
+  /** The voucher could not be applied at all (transport, stay unavailable). */
   voucherFailed: string;
-  /** Voucher was processed and rejected / not recognized. */
+  /** The voucher was processed and rejected. */
   voucherRejected: string;
 }
+/** What a checkout flow is built from. */
 interface CheckoutFlowOptions {
+  /** PMS id of the rental. */
   rentalId: string;
-  /** The site's SDK accessor (one instance for the flow's lifetime — quote +
-   *  selections + book share its queue and 1 req/s rate limit). The flow never
-   *  disposes it; the owner does. */
-  getSdk: () => WebsiteSdk;
-  /** The current COMPLETE stay, or null while none is in hand (mid-edit, URL
-   *  handover missing). The flow re-quotes whenever it changes. */
-  stay: Stay | null;
-  /** The cancellation rate chosen a step earlier (`?policy=` handover). A SEED
-   *  for the first quote, not the source of truth: once a quote exists, the
-   *  live quote's own `selected` flag is. Null means "whatever the PMS
-   *  pre-selects", which is also what an unknown id degrades to. */
-  chosenPolicy: string | null;
-  /**
-   * Which of a fresh quote's policies may be treated as OFFERED for the
-   * `chosenPolicy` re-apply — REQUIRED, because this is the enforcement point
-   * for the whole offer-withdrawal rule: a rate stops being an offer when the
-   * stay moves inside the standard rate's cancellation window, at which point
-   * the cheaper non-refundable one is the identical booking for less. Every
-   * route onto the checkout passes through this check (a stale link, a
-   * hand-built `?policy=`, an in-page date edit), so all of them lapse to the
-   * PMS pre-selection together.
-   */
-  filterOfferedPolicies: (policies: QuoteCancellationPolicy[], arrival: Date) => QuoteCancellationPolicy[];
-  messages: CheckoutFlowMessages;
-  /** Called when a quote returns `AmbiguousMultiRate` / `UnresolvableMultiRate`
-   *  — a PMS rate-configuration fault, not a booked-out stay. Route these to
-   *  monitoring or site operations. */
-  onRateConfigurationFault?: ((info: {
-    code: QuoteUnavailableCode;
-    rentalId: string;
-  }) => void) | undefined;
-  /** The SDK locale: the PMS answers in that language (quote lines, reasons,
-   *  policy names). */
+  /** The PMS answers in this language (quote lines, reasons, rate names). */
   locale: Locale;
-  /** Where the payment provider sends the guest back to (relative to the
-   *  site's origin). Default: the platform's `/buchen/bestaetigung`; a site
-   *  with its own return route passes it here. */
-  returnPath?: string | undefined;
+  /** Where the payment provider returns to, relative to the site origin. Required: routes are the
+   *  site's. */
+  returnPath: string;
+  /** `readCheckoutHandover(location.search, …)`. */
+  handover: CheckoutHandover;
+  /** Rental identity for the payment-return page; parked in sessionStorage on `start()`. */
+  context?: CheckoutContext | undefined;
+  /** Where the rate is chosen: "rental-page" (default) applies the carried `?policy=` and states it;
+   *  "checkout" makes the offered rates choosable here (`selectPolicy`). */
+  policyChoice?: PolicyChoiceMode | undefined;
+  /** Ids of the consent checkboxes the UI renders ("terms", "privacy", additional-terms ids); each
+   *  must be ticked before `book()`. Default none (every consent is a notice). */
+  requiredConsents?: readonly string[] | undefined;
+  /** The transfer account holder when the PMS sends none (v9 hub): the operator's name. */
+  bankHolderFallback?: string | undefined;
+  /** `limits` cap the guest editor; `defaultAdults` seeds a stay picked on a page that arrived
+   *  without one; `childAge` is the age band (a handed-over age outside it is asked again). */
+  guests?: GuestOptions | undefined;
+  /** The site's minimum stay in nights on top of the PMS rules (the value Quote takes): `setDates`
+   *  refuses a shorter range. Default none (the quote enforces the PMS's own minimum). */
+  minStayNights?: number | undefined;
+  /** Catalogue capacity (caps the party until `loadGuestCaps` brings availability's, and where that
+   *  states none) and the pets flag (a dog cannot be added without it; a handed-over one can be
+   *  removed and is still sent). */
+  caps?: Pick<GuestCaps, "maxGuests" | "petsAllowed"> | undefined;
+  /** The sentences the flow reports itself (the checkout copy satisfies them). */
+  messages: CheckoutMessages;
+  /** Receives every checkout event: `rate-fault` once per stay, `booked`, `payment-started`.
+   *  Without it a rate fault is logged with console.warn. */
+  onEvent?: ((detail: CheckoutEventDetail) => void) | undefined;
+}
+/** Where the checkout stands. */
+type CheckoutPhase = {
+  kind: "loading";
+} |
+/** No complete stay arrived (missing or invalid dates). */
+{
+  kind: "missing-stay";
+} | {
+  kind: "ready";
+} |
+/** The first quote was refused (the SDK reason, or `messages.rateFault` / `unavailable`). */
+{
+  kind: "unavailable";
+  reason: string;
+} |
+/** The first quote failed on transport (`retry()`). */
+{
+  kind: "error";
+} |
+/** `book()` succeeded; `confirmation` is set. */
+{
+  kind: "booked";
+};
+/** One reason the order button is off, in the order the UI should mention them. */
+type CheckoutBlocker = "no-quote" | "price-pending" | "busy" | "issue" | "child-ages" | "insurance-documents" | "consents";
+/** One extra as the UI renders it. */
+interface CheckoutService extends QuoteAddonService {
+  /** Units chosen (0 = not booked). */
+  count: number;
+  /** False at `maxPerBooking` (default 99), while unavailable, or while busy. */
+  canAdd: boolean;
+  /** True while `count > 0`: an unavailable service can still be removed. */
+  canRemove: boolean;
+}
+/** The rate the quote carries and the rates the guest may still choose. */
+interface CheckoutPolicyState {
+  /** The rate the quote carries, or null when the PMS sends none (v9). */
+  applied: QuoteCancellationPolicy | null;
+  /** The rates still offered for this arrival (the offer-withdrawal rule); a picker renders these. */
+  offered: readonly QuoteCancellationPolicy[];
+  /** Every rate on the quote, for the summary's terms (a rate that can no longer be cancelled is what
+   *  must be said before paying). */
+  all: readonly QuoteCancellationPolicy[];
+  /** Last day of free cancellation under the applied rate, or null. */
+  freeCancellationUntil: IsoDay | null;
+  /** The rate model for the UI (`describePolicyOffer`, surface "checkout"; no branch prices). */
+  offer: PolicyOffer;
+}
+/** Null when there is nothing to choose (no insurance, the v10 placeholder, no selectable product). */
+interface CheckoutInsuranceState {
+  /** Products this checkout can complete: ride-along, with their pre-contractual documents. */
+  options: readonly QuoteInsuranceOption[];
+  /** The "no insurance" label, verbatim from the SDK. */
+  noneLabel: string;
+  /** The product the quote carries, or null for none. */
+  chosen: QuoteInsuranceOption | null;
+  /** Progress through the § 7 VVG document step. */
+  documents: InsuranceDocsState;
+  /** The documents the guest must open for `chosen` (the shown set, never a label whitelist). */
+  requiredDocuments: readonly {
+    label: string;
+    url: string;
+  }[];
+  /** True while `chosen` blocks booking. */
+  documentsPending: boolean;
+}
+/** The voucher field's state. */
+interface CheckoutVoucherState {
+  /** The code the shown price includes, or null. */
+  applied: string | null;
+  /** Why the last code did not apply, or null. */
+  error: string | null;
+  /** A code is being priced. */
+  checking: boolean;
 }
+/** A re-quote that failed or found the stay unavailable. */
 interface CheckoutIssue {
-  /** The stayKey the issue belongs to — a different stay re-arms the loop. */
-  key: string;
+  /** What to tell the guest (the SDK's reason or a messages sentence). */
   reason: string;
-  /** Transport errors offer a manual retry; unavailability does not. */
+  /** Transport errors offer `retry()`; unavailability does not. */
   retryable: boolean;
 }
-/** Everything a UI renders. A new object per change; unchanged otherwise, so
- *  `useSyncExternalStore` and friends can compare by reference. */
-interface CheckoutFlowState {
+/** Everything a UI renders. A new object per change, unchanged otherwise. */
+interface CheckoutState {
+  /** Where the checkout stands. */
   phase: CheckoutPhase;
+  /** A booking, or an option (`?kind=option` with `allowOption`). */
+  kind: BookingKind;
+  /** The stay being edited (the source of truth after the handover). */
+  stay: Stay | null;
+  /** What the guest editor may offer for this rental. */
+  bounds: GuestBounds;
+  /** The quote view (of the last priced stay while `pricePending`). */
   view: QuoteView | null;
-  counts: Record<string, number>;
+  /** The extras with their chosen counts. */
+  services: readonly CheckoutService[];
+  /** The applied rate and the offered ones. */
+  policy: CheckoutPolicyState;
+  /** The insurance choice, or null when there is nothing to choose. */
+  insurance: CheckoutInsuranceState | null;
+  /** The voucher field's state. */
+  voucher: CheckoutVoucherState;
+  /** Checkbox state per required consent id. */
+  consents: Readonly<Record<string, boolean>>;
+  /** The shown price does not belong to the shown stay yet. */
+  pricePending: boolean;
+  /** A selection or a re-quote is running. */
   busy: boolean;
+  /** The last re-quote's failure for this stay, or null. */
   issue: CheckoutIssue | null;
+  /** The SDK's reason for a refused selection (an extras/rate combination it cannot price). */
   selectionError: string | null;
-  quotedKey: string | null;
-  stayKey: string | null;
-  /** A re-quote is pending: the shown price does not match the shown stay. */
-  pricePending: boolean;
-  /** Booking is blocked (stale price, in-flight mutation, issue, or documents pending). */
-  blocked: boolean;
-  chosenInsurance: QuoteInsuranceOption | undefined;
-  insuranceDocs: InsuranceDocsState;
-  documentsPending: boolean;
-  voucherApplied: string | null;
-  voucherError: string | null;
-  bookState: "idle" | "submitting" | "error";
+  /** Empty when `book()` is allowed. */
+  blockers: readonly CheckoutBlocker[];
+  /** The order button's state: idle, booking, or a failed `book()`. */
+  submit: "idle" | "submitting" | "failed";
+  /** The confirmation after `book()`, or null. */
   confirmation: BookingConfirmation | null;
-  payBusyKey: string | null;
-  payError: boolean;
+  /** The payment buttons' state: the option redirecting now, and a failed start. */
+  payment: {
+    busyOption: SubmittableBookingPaymentOption | null;
+    failed: boolean;
+  };
 }
-/** The actions a UI calls. Stable functions for the flow's lifetime. */
-interface CheckoutFlowActions {
+/** The actions a UI calls; stable for the flow's lifetime. */
+interface CheckoutActions {
+  /** A new date range from the stay editor (at least one night, and at least `minStayNights`; a
+   *  shorter range is ignored); re-quotes after a short debounce. */
+  setDates(start: IsoDay, end: IsoDay): void;
+  /** A new party from the guest editor; clamped to `bounds` (pets per the caps rule); re-quotes
+   *  after a short debounce. */
+  setParty(party: Party): void;
+  /** Load the rental's availability caps once (persons, adults, and on v9 the children and pets
+   *  rules), so `bounds` follow them. Call it when the guest editor opens: the page's first request
+   *  stays the quote. A failure is logged and the catalogue caps stay. Idempotent. */
+  loadGuestCaps(): void;
+  /** Add (+1) or remove (−1) one unit of an extra. */
   changeService(id: string, delta: 1 | -1): void;
+  /** Only with `policyChoice: "checkout"`, and only to an offered rate. */
+  selectPolicy(id: string): void;
+  /** A selectable product's id, or null for none. */
   selectInsurance(id: string | null): void;
-  openInsuranceDoc(url: string): void;
-  confirmInsuranceDocs(productKey: string, confirmed: boolean): void;
+  /** The guest opened one of the chosen product's documents (the § 7 VVG step). */
+  openInsuranceDocument(url: string): void;
+  /** The confirmation is keyed by the chosen product inside the flow, so no UI can confirm the
+   *  wrong one. */
+  confirmInsuranceDocuments(confirmed: boolean): void;
+  /** Re-quote with a code (null removes it); the previous quote stays when the code is rejected.
+   *  Ignored while the shown price is not the shown stay's (`pricePending`, or a failed re-quote). */
   applyVoucher(code: string | null): void;
-  /** ⚠ USER-initiated only: creates a real booking. */
-  book(contact: BookingContactForm): void;
-  /** ⚠ USER-initiated only: redirects to the real payment provider. */
-  pay(key: string, option: PaymentScheduleView["options"][number]): void;
-  clearIssue(): void;
-}
-interface CheckoutFlow extends Store<CheckoutFlowState>, CheckoutFlowActions {
-  /** Feed the UI's current inputs. `stay` and `chosenPolicy` drive the
-   *  re-quote; messages and callbacks are read at call time. */
-  update(options: CheckoutFlowOptions): void;
-  /** Arm the auto-quote. Idempotent; call once the UI is mounted. */
+  /** Tick or untick a required consent checkbox. */
+  setConsent(id: string, value: boolean): void;
+  /** Re-quote after a transport issue. */
+  retry(): void;
+  /** ⚠ USER-initiated only: creates a real booking. Refused while `blockers` is not empty. */
+  book(contact: BookingContact): void;
+  /** ⚠ USER-initiated only: redirects to the real payment provider. Refused for bank transfer and
+   *  while another payment is starting. */
+  pay(option: SubmittableBookingPaymentOption): void;
+}
+/** The checkout store: its state, its actions and its lifecycle. */
+interface CheckoutFlow extends Store<CheckoutState>, CheckoutActions {
+  /** Park the context and price the handed-over stay. Idempotent. */
   start(): void;
   /** Cancel pending work and drop every in-flight result. */
   dispose(): void;
 }
-/** What a UI binding hands to the rendering code: the state plus the actions. */
-type CheckoutFlowApi = CheckoutFlowState & CheckoutFlowActions;
-export declare function createCheckoutFlow(initialOptions: CheckoutFlowOptions): CheckoutFlow;
-//#endregion
-//#region src/checkout/card-order.d.ts
-export declare function stabilizeCardOrder(view: QuoteView, order: Map<string, number>): QuoteView;
+/** The checkout store. The SDK source is resolved once, on the first request. */
+type CreateCheckoutFlow = (sdk: SdkSource, options: CheckoutFlowOptions) => CheckoutFlow;
+/** See {@link CreateCheckoutFlow}. */
+export declare const createCheckoutFlow: CreateCheckoutFlow;
 //#endregion
-//#region src/checkout/validation.d.ts
-/**
- * Contact-form field validation — the checkout's data-quality behavior,
- * framework-free.
- *
- * Extracted from the sites' checkout island (`CheckoutFlow.tsx`). The RULES live here so every site validates a booking
- * contact the same way; the MESSAGES are copy and stay per-site — every
- * function takes them as a parameter (the site's `CheckoutFlowCopy` object
- * satisfies `ValidationMessages` structurally, so skins pass their merged copy
- * straight through).
- */
-/** The subset of the checkout copy the validators read. A site's full copy
- *  object satisfies this structurally. */
+//#region src/forms/validation.d.ts
+/** Salutation choices. The labels are copy; the wire value is fixed, so the PMS sees one vocabulary in
+ *  every locale (an agency's staff read "Frau"/"Herr" whatever language the guest booked in). */
+type Salutation = "female" | "male" | "unspecified";
+/** What reaches the PMS as `title`. The checkout guest form sends none for "unspecified" (the booking
+ *  contact's title is optional); the contact form sends "Keine Angabe" (the contact API requires one). */
+export declare const SALUTATION_WIRE_VALUES: Readonly<Record<Salutation, string>>;
+/** Every sentence the field rules can return. A site's merged checkout copy satisfies it
+ *  structurally; `phoneRequired`, `housenumberRequired` and `salutationRequired` are read only when
+ *  the form makes that field required. */
 interface ValidationMessages {
+  /** A forename left empty. */
   forenameRequired: string;
+  /** A surname left empty. */
   surnameRequired: string;
+  /** A street left empty. */
   streetRequired: string;
+  /** A town left empty. */
   cityRequired: string;
+  /** A postal code left empty. */
   postalcodeRequired: string;
+  /** An email left empty. */
   emailRequired: string;
+  /** A present email that is no address. */
   emailInvalid: string;
+  /** A required phone left empty. */
+  phoneRequired: string;
+  /** A number that carries "+CC" but has the wrong length. */
   phoneInvalid: string;
+  /** A national number the rules cannot prefix (no country code known). */
   phoneNeedsDialCode: string;
+  /** A required house number left empty. */
+  housenumberRequired: string;
+  /** A required salutation left unchosen. */
+  salutationRequired: string;
+  /** No country chosen. */
+  countryRequired: string;
+  /** A present German postal code that is not five digits. */
   postalcodeInvalidDE: string;
+  /** A present Austrian postal code that is not four digits. */
   postalcodeInvalidAT: string;
+  /** A present Swiss postal code that is not four digits. */
   postalcodeInvalidCH: string;
+  /** Non-blocking: the street seems to carry the house number. */
   streetHouseNumberWarning: string;
 }
-export declare function normalizePhone(raw: string, dial: string | undefined): string;
-export declare function phoneError(raw: string, dial: string | undefined, c: ValidationMessages): string | undefined;
-export declare function emailError(raw: string, c: ValidationMessages): string | undefined;
-export declare function postalcodeError(raw: string, country: string, c: ValidationMessages): string | undefined;
-export declare function streetWarning(raw: string, c: ValidationMessages): string | undefined;
-export declare const VALIDATED_FIELDS: readonly ["forename", "surname", "email", "phone", "street", "postalcode", "city"];
-/** Validate one named field. Takes the selected COUNTRY plus its calling code
- *  (`dial`, undefined when the register has none for it): two validators depend
- *  on the country — the phone via the dial code, the PLZ via its format rule.
- *  The dial code is passed in rather than looked up because the ISO→dial
- *  mapping lives with the site's country register (its localized "Land"
- *  options), not here. */
-export declare function fieldError(name: string, value: string, country: string, dial: string | undefined, c: ValidationMessages): string | undefined;
-/** Country options in the shape the site's country register provides —
- *  `[code, label]` pairs, a featured group plus the full ISO register. Kept
- *  structural so the site's own `CountryGroups` type satisfies it. */
-interface CountryGroupsLike {
-  featured: ReadonlyArray<readonly [string, string]>;
-  all: ReadonlyArray<readonly [string, string]>;
-}
-export declare function detectCountry(countries: CountryGroupsLike): string;
+/** Separators → spaces, `00CC` → `+CC`, a trunk `0` → `+<dial>` (the calling code of the selected
+ *  country, digits only). Returns the normalized number, or null for a blank input. Without a `dial` a
+ *  national number stays as typed, so `phoneError` asks for the code instead of guessing one. */
+type NormalizePhone = (raw: string, dial: string | undefined) => string | null;
+/** An optional phone: blank is valid (null). Present, it must normalize to `+<1-9><6–14 digits>`
+ *  (E.164 caps the total at 15). A "+CC" number of the wrong length gets `phoneInvalid`; anything
+ *  without a country code gets `phoneNeedsDialCode`. Required-ness is the form's own check. */
+type PhoneError = (raw: string, dial: string | undefined, messages: ValidationMessages) => string | null;
+/** Required, and shaped like an address with a dotted top-level domain (catches "name@gmail"). The
+ *  endpoint's own pattern stays the authority; this is the early, coarse gate. Takes only the two
+ *  messages it reads, so the contact form's copy satisfies it too. */
+type EmailError = (raw: string, messages: Pick<ValidationMessages, "emailRequired" | "emailInvalid">) => string | null;
+/** Required for every country; a format check only for DE (5 digits), AT (4) and CH (4). Every other
+ *  country is accepted as typed: rejecting a valid foreign address is the most expensive mistake a
+ *  booking form can make, and no single pattern covers "1234 AB" or an Eircode. */
+type PostalcodeError = (raw: string, country: CountryCode, messages: ValidationMessages) => string | null;
+/** A non-blocking hint when the street ends in a number that is probably the house number: the
+ *  house-number field is empty, or holds that same number twice. "Bundesstraße 96" with "Nr. 3" is a
+ *  real street and gets no hint; digits inside a name ("Straße des 17. Juni") never do. */
+type StreetWarning = (street: string, housenumber: string, messages: ValidationMessages) => string | null;
+/** See {@link NormalizePhone}. */
+export declare const normalizePhone: NormalizePhone;
+/** See {@link PhoneError}. */
+export declare const phoneError: PhoneError;
+/** See {@link EmailError}. */
+export declare const emailError: EmailError;
+/** See {@link PostalcodeError}. */
+export declare const postalcodeError: PostalcodeError;
+/** See {@link StreetWarning}. */
+export declare const streetWarning: StreetWarning;
+//#endregion
+//#region src/checkout/guest-form.d.ts
+/** Every field, in visual order (the order `firstInvalid` walks). `salutation` holds a `Salutation`
+ *  or "" (none chosen); `country` an ISO code. */
+type GuestFormField = "salutation" | "forename" | "surname" | "email" | "phone" | "street" | "housenumber" | "postalcode" | "city" | "country" | "note";
+/** Fields a site may make required on top of the minimum (forename, surname, email, street, postal
+ *  code, city, country): an agency that calls back requires the phone, one whose PMS splits the
+ *  address requires the house number. */
+type OptionalGuestField = "salutation" | "phone" | "housenumber";
+/** What the guest-data form is built from. */
+interface GuestFormOptions {
+  /** The validators' copy (the checkout copy satisfies it structurally). */
+  messages: ValidationMessages;
+  /** The Land options (`countryOptions` at build). */
+  countries: CountryGroups;
+  /** Default none. */
+  requiredFields?: readonly OptionalGuestField[] | undefined;
+  /** The Land when the browser languages name none of `countries` (with `languages: []` simply the
+   *  starting Land), and the dial code of a national phone number while no Land is chosen. Default "DE". */
+  fallbackCountry?: CountryCode | undefined;
+  /** `navigator.languages`, passed in by the UI (headless reads no navigator). Default none. */
+  languages?: readonly string[] | undefined;
+}
+/** What a UI renders. */
+interface GuestFormState {
+  /** Every field's current value. */
+  values: Readonly<Record<GuestFormField, string>>;
+  /** Blocking errors that are SHOWN (judged on blur, on change of a shown one, or on submit). */
+  errors: Readonly<Partial<Record<GuestFormField, string>>>;
+  /** Non-blocking hints (the street/house-number heuristic); never stop `submit()`. */
+  warnings: Readonly<Partial<Record<GuestFormField, string>>>;
+  /** The fields the guest has left once (their present value is judged). */
+  touched: ReadonlySet<GuestFormField>;
+  /** After a failed `submit()`: the topmost invalid field, for focus; null otherwise. */
+  firstInvalid: GuestFormField | null;
+}
+/** The guest-data form store: its state and its actions. */
+interface GuestForm extends Store<GuestFormState> {
+  /** Typing. A shown error is re-judged and clears once valid; changing the country re-checks a
+   *  present postal code and phone (a German error on "1234 AB" clears when the guest picks NL). */
+  set(field: GuestFormField, value: string): void;
+  /** Leaving a field: the phone is normalized in place (the guest sees "+49 176 …"), a present value
+   *  is judged, an empty one waits for submit. */
+  blur(field: GuestFormField): void;
+  /** Judge everything. Returns the contact for `book()`, or null with every error shown and
+   *  `firstInvalid` set. Warnings never block. */
+  submit(): BookingContact | null;
+  /** Stop publishing: later calls change nothing. */
+  dispose(): void;
+}
+/** The guest data form store. */
+type CreateGuestForm = (options: GuestFormOptions) => GuestForm;
+/** See {@link CreateGuestForm}. */
+export declare const createGuestForm: CreateGuestForm;
 //#endregion
 //#region src/checkout/structure.d.ts
-/**
- * The checkout's STRUCTURAL requirements — what must be on screen, in what
- * order, regardless of who produced the markup.
- *
- * WHY THIS EXISTS. Headless holds the RULES (the § 7 VVG document gate, the
- * stale-price booking guard) but no markup, so a site that renders its own
- * checkout UI can silently drop a legal obligation — the § 312j BGB
- * Button-Lösung wording, the insurance documents listed before the guest's
- * confirmation, the price stated directly above the order button — and every
- * unit test still passes. This module is a contract over the RENDERED result.
- * The imported `Booking` component satisfies it by construction; a site's own
- * checkout is a developer's review item when it changes. The platform does
- * NOT run this assertion at publish time (decided 2026-09-11,
- * docs/website-platform/process/10-dist-checks.md "Custom checkouts").
- *
- * Two halves:
- *   - `CHECKOUT_PARTS`: the `data-part` vocabulary. Imported components carry
- *     these attributes; a site's own markup must keep them so this check
- *     (and a site's own CSS) can find the elements.
- *   - `CHECKOUT_STRUCTURE` + `assertCheckoutStructure(root)`: the requirements
- *     and a pure DOM check over a rendered checkout (a browser page or a
- *     jsdom document in a test). Every requirement names the legal
- *     basis it exists for, so a failure message tells the reader WHY.
- */
+/** The legal `data-part` vocabulary. Imported components carry it; a custom checkout must keep it.
+ *  Style-only hooks are not here (components `BOOKING_PARTS`). Renaming a part is a major. */
 export declare const CHECKOUT_PARTS: {
-  /** The one place the guest is told the price they are about to owe. */
+  /** The price the guest is about to owe (the summary, and directly above the order button). */
   readonly priceTotal: "checkout-price-total";
-  /** The § 312j order button. */
+  /** The insurance premium: a second figure beside each total, never summed into it. */
+  readonly insurancePremium: "checkout-insurance-premium";
+  /** The order button. Carries `data-booking-kind`. */
   readonly submit: "checkout-submit";
-  /** The terms line (AGB + privacy triggers). */
+  /** The terms notice, or the terms checkbox's label (AGB accepted, privacy information noted). */
   readonly terms: "checkout-terms";
-  /** One link per mandatory insurance document (§ 7 VVG). */
+  /** Every consent checkbox (terms, privacy acknowledgement, additional terms). */
+  readonly consent: "checkout-consent";
+  /** One link per pre-contractual insurance document (§ 7 VVG). */
   readonly insuranceDocument: "checkout-insurance-document";
   /** The guest's receipt confirmation for those documents. */
   readonly insuranceConfirm: "checkout-insurance-confirm";
 };
+/** One value of `CHECKOUT_PARTS`. */
 type CheckoutPart = (typeof CHECKOUT_PARTS)[keyof typeof CHECKOUT_PARTS];
-/** German "kostenpflichtig bestellen"-class labels the courts have accepted
- *  for § 312j Abs. 3 BGB. The check is on the RENDERED button text, so a site
- *  may re-voice the label — but only within this class. */
-export declare const BUTTON_SOLUTION_PATTERN: RegExp;
-export declare const CHECKOUT_STRUCTURE: {
-  readonly "submit-present": {
-    readonly basis: "§ 312j Abs. 3 BGB (Button-Lösung)";
-    readonly description: "exactly one order button carries data-part=checkout-submit";
-  };
-  readonly "submit-wording": {
-    readonly basis: "§ 312j Abs. 3 BGB (Button-Lösung)";
-    readonly description: "the order button's visible text is a 'zahlungspflichtig buchen'-class label";
-  };
-  readonly "total-before-submit": {
-    readonly basis: "§ 312j Abs. 2 BGB (price stated immediately before the order)";
-    readonly description: "a data-part=checkout-price-total precedes the order button in DOM order";
-  };
-  readonly "terms-before-submit": {
-    readonly basis: "§ 312d BGB / Art. 13 DSGVO (terms + privacy notice before contracting)";
-    readonly description: "a data-part=checkout-terms precedes the order button";
-  };
-  readonly "insurance-docs-before-confirm": {
-    readonly basis: "§ 7 Abs. 1 VVG, § 4 VVG-InfoV (documents before the declaration)";
-    readonly description: "when an insurance confirmation is rendered, at least one insurance document precedes it in DOM order";
-  };
-};
-type CheckoutRequirement = keyof typeof CHECKOUT_STRUCTURE;
+/** The attribute on the order button that names its kind ("booking" | "option"); absent reads as a
+ *  booking, so a button can only claim the option wording by saying it is one. */
+export declare const BOOKING_KIND_ATTRIBUTE: "data-booking-kind";
+/** The label classes the order button's visible text must match, per kind.
+ *  booking: "(zahlungspflichtig|kostenpflichtig) (buchen|bestellen|reservieren)", "jetzt kaufen",
+ *           "(book|order) with obligation to pay", "book and pay", "pay now", "buy now";
+ *  option:  "unverbindlich (reservieren|anfragen)", "reserve without obligation",
+ *           "non-binding reservation".
+ *  A site may re-voice the label, but only within its class. The English and option classes await
+ *  a legal review (no case law covers them). */
+type SubmitWording = Readonly<Record<BookingKind, RegExp>>;
+/** One requirement: its legal basis and what it checks. */
+interface StructureRequirement {
+  /** The legal basis ("§ 312j Abs. 3 BGB"). */
+  readonly basis: string;
+  /** What the requirement checks, in one sentence. */
+  readonly description: string;
+}
+/** Every requirement `assertCheckoutStructure` checks, by id. */
+type CheckoutStructure = Readonly<Record<"submit-present" | "submit-wording" | "total-before-submit" | "terms-before-submit" | "consents-before-submit" | "insurance-docs-before-confirm" | "premium-before-submit", StructureRequirement>>;
+/** A requirement id. */
+type CheckoutRequirement = keyof CheckoutStructure;
+/** One failed requirement, naming its legal basis so a failure says why. */
 interface StructureViolation {
+  /** The failed requirement's id. */
   requirement: CheckoutRequirement;
+  /** Its legal basis. */
   basis: string;
+  /** What was found instead (the offending element or text). */
   detail: string;
 }
-export declare function assertCheckoutStructure(root: ParentNode): StructureViolation[];
+/** A pure DOM check over a rendered checkout (`document` in a browser, a jsdom document in a test).
+ *  Returns every violation; empty = compliant. Everything is judged relative to the one order
+ *  button, in DOM order (a sticky bottom bar after the body is fine while the total, terms and
+ *  consents precede it). The insurance rules apply only when a confirmation control is rendered:
+ *  the duty attaches to concluding an insurance contract. */
+type AssertCheckoutStructure = (root: ParentNode) => StructureViolation[];
+export declare const SUBMIT_WORDING: SubmitWording;
+export declare const CHECKOUT_STRUCTURE: CheckoutStructure;
+/** See {@link AssertCheckoutStructure}. */
+export declare const assertCheckoutStructure: AssertCheckoutStructure;
 //#endregion
-//#region src/dates.d.ts
-export declare function parseParam(value: string | null | undefined): Date | undefined;
-export declare function parseGermanParam(value: string | null | undefined): Date | undefined;
-/** A flexible-length stay ("3–5 Nächte") as the URL carries it. Off until the
- *  search UI offers it; the keys are reserved so a site can enable it. */
-export declare const NIGHT_RANGE_ENABLED = false;
-export interface NightRange {
-  min: number;
-  max: number;
-}
-export declare const NIGHT_RANGE_KEYS: readonly ["minNights", "maxNights", "nights_min", "nights_max"];
-export declare function parseNightRange(params: URLSearchParams): NightRange | null;
-//#endregion
-//#region src/format.d.ts
-/**
- * Display tidy for an SDK pre-formatted German-locale price ("1.234,00 €").
- * Nearly every stay is whole euros, so the trailing ",00" is noise — dropped only
- * when it is the zero-cents group at the end, so real cents ("1.234,50 €") stay.
- * A real value formatted for display, nothing fabricated; other formats pass.
- */
-export declare function tidyPrice(formatted: string): string;
-//#endregion
-//#region src/availability.d.ts
-/**
- * The per-night price a calendar CELL shows, rounded to whole euros:
- * "116,43 €" -> "116 €", "116,50 €" -> "117 €".
- *
- * A month grid is thirty-odd numbers seen at a glance and acted on by NONE of
- * them — the guest picks a range, and the quote under the calendar then states
- * the stay to the last cent. Two decimals in every cell buy precision nobody
- * reads, at the one size where the digits are already tight.
- *
- * ROUNDS TO NEAREST, AND THAT IS THE POINT OF THE FUNCTION. Stripping the cents
- * with a regex is one line and understates every priced night by up to 99
- * cents, always in the direction that flatters the price. That is the shape of
- * claim a host has to stand behind, so the error goes both ways here and is
- * capped at 50 cents on a figure that is explicitly indicative.
- *
- * Parses the German format rather than doing string surgery on it: "." groups
- * thousands, "," is the decimal. Anything that does not match that shape —
- * another locale, no decimal group, a price the SDK formatted differently — is
- * returned UNCHANGED. A display tidy must never turn a price it did not
- * understand into a wrong one.
- *
- * This runs where `priceByDay` is BUILT rather than where a cell renders it, so
- * every calendar fed from this map agrees: the widget's picker and the
- * checkout's copy, which reads the same shape.
- */
-export declare function nightlyPrice(formatted: string, locale?: Locale): string;
-type VofficeSdk$1 = WebsiteSdk;
-export interface InitialAvailability {
-  /** ISO dates (`YYYY-MM-DD`) the SDK flags as a valid check-in/arrival day. */
-  canStart: Set<string>;
-  /** ISO dates the rental is genuinely unbookable on (booked / closed / past the
-   *  bookable horizon — the SDK's "hard" statuses). The picker STRIKES these
-   *  through. A disabled day NOT in this set is only blocked by a rule for the
-   *  current phase (e.g. check-in-not-allowed) and is merely dimmed — it could
-   *  work in another context. */
-  hardBlocked: Set<string>;
-  /** Per-night price by ISO date — the SDK's localized string, display-tidied
-   *  to drop the noise ",00" (e.g. "120 €"). Only days the SDK prices. */
-  priceByDay: Map<string, string>;
-  /** Localized reason a day is blocked, by ISO date (the SDK's own `tooltip`,
-   *  e.g. "An diesem Tag ist keine Anreise möglich."). */
-  tooltipByDay: Map<string, string>;
-  /** Occupancy caps the SDK states for this rental (null when omitted). The
-   *  picker caps the guest stepper at these so a quote can't fail on too many
-   *  guests; the below-minimum case is left to the quote (the SDK is the
-   *  arbiter of a bookable party), so `minPersons` isn't surfaced here. */
-  maxPersons: number | null;
-  maxAdults: number | null;
-  childrenAllowed: boolean | null;
-  maxPets: number | null;
+//#region src/forms/contact.d.ts
+/** The built-in fields: the contact API has a slot for each (names follow the SDK's paths). */
+type ContactFieldName = "salutation" | "forename" | "surname" | "email" | "phone" | "country" | "street" | "postalCode" | "city" | "message";
+/** Grid width of a field on wide screens (one column below the form's breakpoint). */
+type FieldWidth = "full" | "half";
+/** Value rules a spec may declare. Judged only on a present value; required-ness is its own check
+ *  with its own message. `pattern` matches the WHOLE value (anchored, `v` flag, as the browser's
+ *  `pattern` attribute). `min`/`max` compare numbers for a number field and ISO days for a date field
+ *  (`"today"` is today); `step` counts from `min` (default 0). */
+interface ValueConstraints {
+  /** Lowest value: a number for a number field, an ISO day or "today" for a date field. */
+  readonly min?: number | string;
+  /** Highest value, in the same terms as `min`. */
+  readonly max?: number | string;
+  /** A number field's step, counted from `min` (default 0). */
+  readonly step?: number;
+  /** A regular expression the whole value must match (anchored, `v` flag). */
+  readonly pattern?: string;
+  /** Most characters. */
+  readonly maxLength?: number;
+  /** Shown when a present value fails a constraint; default `messages.fieldInvalid`. */
+  readonly invalidMessage?: string;
 }
-export interface EndAvailability {
-  /** ISO dates the SDK flags as a valid check-out/departure for the chosen
-   *  start (min-stay + checkout rules already applied by the SDK). */
-  canEnd: Set<string>;
-  /** ISO dates genuinely unbookable (booked / the range would cross an
-   *  unavailable night that is itself unavailable). STRUCK through. A disabled
-   *  day not here is only rule-blocked for this start (min-stay, check-out-not-
-   *  allowed, same-day, would-be a new start) and is merely dimmed. */
-  hardBlocked: Set<string>;
-  /** Localized reason a departure is blocked, by ISO date (min-stay-not-met,
-   *  check-out-not-allowed, range-crosses-booked, …) — the SDK's own `tooltip`. */
-  tooltipByDay: Map<string, string>;
-}
-/** Possible check-in days + occupancy caps for `rentalId` across the window.
- *  The caller's SDK instance is reused so its 30s per-rental cache spans the
- *  picker's lifetime. */
-export declare function fetchInitialAvailability(sdk: VofficeSdk$1, rentalId: string, calculateFromDate: string, calculateThroughDate: string, locale: Locale): Promise<InitialAvailability>;
-/** Possible check-out days for a chosen `selectedStartDate`. */
-export declare function fetchEndAvailability(sdk: VofficeSdk$1, rentalId: string, calculateFromDate: string, calculateThroughDate: string, selectedStartDate: string, locale: Locale): Promise<EndAvailability>;
-//#endregion
-//#region src/search.d.ts
-type VofficeSdk = WebsiteSdk;
-export interface SearchImage {
-  src: string;
-  srcset?: string | undefined;
-  alt: string;
+/** A built-in field with one or more decisions changed. */
+interface BuiltInFieldSpec extends ValueConstraints {
+  /** The built-in field this spec changes. */
+  readonly field: ContactFieldName;
+  /** Default: salutation, forename, surname, email, country and message are required; phone, street,
+   *  postalCode and city are optional. */
+  readonly required?: boolean;
+  /** Replaces the copy label ("Telefon (tagsüber)", "Name" on a surname-only form). */
+  readonly label?: string;
+  /** Default "full" ("half" pairs two fields on wide screens). */
+  readonly width?: FieldWidth;
+  /** `salutation` only: the choices offered, in order. Default all three. */
+  readonly options?: readonly Salutation[];
+  /** `salutation`: a `Salutation`; `country`: a `CountryCode`; others: text. An answer chosen in
+   *  advance, still editable ("unspecified" preselected is an answer, not an absence). */
+  readonly defaultValue?: string;
 }
-/** One window the SDK suggests for a rental it could not match exactly — a
- *  concrete, priced, bookable stay.
- *
- *  EVERY FIELD IS READ OFF THE PERIOD THE SDK SENDS, never off the rental. A
- *  promotion belongs to a (rental x window) pair — the same rental prices
- *  undiscounted in another window — so the price and the discount are read from
- *  the same period together, the way `mapAlternativeEntry` already resolved them
- *  for the single window it used to render. A window whose dates the feed omits
- *  has no label and never reaches this list; one the feed does not price shows
- *  no price rather than a placeholder. */
-export interface AlternativePeriod {
-  /** „31. Aug - 4. Sep", composed from this window's own start and end. */
-  label: string;
-  /** The detail-page link carrying THIS window's dates, so the rental opens on
-   *  the stay the row names rather than on the user's (unmatched) query. */
-  href: string;
-  /** This window's `formattedTotal`, verbatim. null when the feed omits it. */
-  priceLabel: string | null;
-  /** This window's length in nights. null when the feed omits a date. */
-  nights: number | null;
-  /** True when THIS window is discounted — the presence of the SDK's `discount`
-   *  block on this period, nothing inferred. Carried so the three discount facts
-   *  arrive together from `mapDiscount`, exactly as they do on the card. */
-  isOffer: boolean;
-  /** This window's pre-discount total, for the struck-through "was" price. */
-  offerOriginalPriceLabel: string | null;
-  /** This window's promotions, the PMS's own labels, verbatim. `amount` is
-   *  LINE-level and must not be printed beside a total — see the note on
-   *  `SearchResultItem.offers`. */
-  offers: {
-    label: string;
-    amount: string | null;
-  }[];
+/** One option of a select extra; `label` is what the reader sees AND what the message line says. */
+interface SelectOption {
+  /** What the value is stored as (and sent). */
+  readonly value: string;
+  /** What the reader sees, and what the message line says. */
+  readonly label: string;
 }
-export interface SearchResultItem {
-  /** PMS id — shared by the result card and its map marker. */
-  id: string;
-  /** `nameOrLabel`, verbatim. */
-  name: string;
-  /** `address.city`, verbatim (empty when the feed omits it). */
-  location: string;
-  /** Internal detail link — `rentalsPath` (see `runLiveSearch`) + the slug
-   *  derived from the name (URL generation), with the user's booking context
-   *  (dates + party size) appended as a query so the search selection carries
-   *  into the rental page. */
-  href: string;
-  images: SearchImage[];
-  /** Parsed out of the SDK highlights; 0 when the highlight is absent. */
-  guests: number;
-  bedrooms: number;
-  area: number;
-  /** Plain-text amenity highlights (the SDK has no icon concept), CARRIED WHOLE.
-   *
-   *  This used to be `highlights.slice(3, 6)` — the SDK opens `highlights` with
-   *  the spec stats the line above already prints, and three was a guess at how
-   *  many. It is not a constant: how many spec lines a feed states depends on
-   *  which of them the PMS has filled and on `rentalHighlightPrioritization`, so
-   *  a feed stating four leaked „55 m²" into the pill row, while the same slice
-   *  ALSO discarded good candidates below position 6.
-   *
-   *  The CARD decides now: `rental-detail-kit`'s `cardHighlights` drops the spec
-   *  block by SHAPE, then `pillRow` merges and caps. A consumer that renders this
-   *  array raw must cap it itself — it is no longer bounded here. */
-  pills: string[];
-  /** `formattedTotal`, verbatim (null when the feed omits a price). */
-  priceLabel: string | null;
-  /** Label for an SDK-provided alternative period, null for exact matches.
-   *  The FIRST of `alternativePeriods` — the SDK returns them best-first — kept
-   *  as its own field because the card's date pill names one window even where
-   *  the chooser lists several. */
-  alternativePeriodLabel: string | null;
-  /** EVERY window the SDK suggests for this card, best-first — not just the one
-   *  `alternativePeriodLabel` names. Empty on exact-match cards.
-   *
-   *  THE FEED STATES MORE THAN ONE AND THIS PROJECT RENDERED ONE. Measured
-   *  against v10 production on 2026-08-27, query
-   *  `start=2026-08-31&end=2026-09-02&adults=2`: 19 alternative entries, and 14
-   *  of them carried TWO priced windows. `mapAlternativeEntry` read
-   *  `alternativePeriods[0]` and dropped the rest, so on three cards in four a
-   *  real, priced, bookable window existed that the guest was never shown. The
-   *  same query's flexible sibling (`month=10-2026&nights=7`) returned exactly
-   *  one window on all 20 entries — so the count is a property of the QUERY, not
-   *  a constant, and every surface reading this must handle both. */
-  alternativePeriods: AlternativePeriod[];
-  /** True only when the SDK flags this item as a non-exact date match. */
-  isAlternativePeriod: boolean;
-  /** Stay length for THIS card's own window, in nights. Set only on
-   *  alternative-period cards (whose date pill describes the SDK's suggested
-   *  window, not the user's search) so the footer's "N Nächte" matches the dates
-   *  shown. null on exact-match cards — they fall back to the page-level
-   *  `nights` (their window IS the user's search). */
-  nights: number | null;
-  /** True when THIS card's window is discounted ("Angebot" badge) — the mere
-   *  PRESENCE of the SDK's `discount` block on the priced result, nothing
-   *  inferred. A promotion belongs to a (rental × window) PAIR, not to a rental:
-   *  the same rental prices undiscounted in another window, so this travels with
-   *  the price, not with the identity. Never derived from a lead-time threshold —
-   *  that number is the customer's PMS setting and moves. */
-  isOffer: boolean;
-  /** `discount.formattedOriginalTotal`, verbatim — the pre-discount total, for
-   *  the struck-through "was" price. null when the feed states a discount but no
-   *  original total: presence of a discount and the ability to price it are
-   *  different facts, so the "was" price gates on its own field. */
-  offerOriginalPriceLabel: string | null;
-  /** `discount.applied`, verbatim — the PMS's own name for each promotion and
-   *  its amount. CARRIED, NEVER AUTHORED: the label names the offer ("Last-Minute
-   *  Angebot" is what this feed states today); writing our own over it would be
-   *  fabricated data. Empty when the feed states a discount it doesn't itemise —
-   *  `isOffer` can be true with nothing here, so the label row gates on length.
-   *
-   *  ⚠ `amount` IS LINE-LEVEL, AND MUST NOT BE SHOWN BESIDE A TOTAL. It is the
-   *  modifier on the rent line, while `offerOriginalPriceLabel` and `priceLabel`
-   *  are totals — so wherever the PMS puts taxes or fees outside the discounted
-   *  line, the three do not reconcile. Measured on a live v10 quote of the same
-   *  stay the search priced: Inklusivpreis 484,35 € − 72,87 € = 411,48 €, plus
-   *  Steuern & Abgaben 10,77 €, total 422,25 €, against a search
-   *  `formattedOriginalTotal` of 497,12 €. Both endpoints agree on every figure;
-   *  the real total saving is 74,87 € because the tax shrank too, while `amount`
-   *  states the rent's 72,87 €. `search-results-kit` renders the LABEL alone for
-   *  this reason — it did render the amount, in 1.10.0, and that was the bug.
-   *  The field STAYS because it is correct DATA: a surface that shows the rent
-   *  line itself may pair it with that line. Do not "fix" it by computing
-   *  `original − total` — that number is nowhere in the feed. */
-  offers: {
-    label: string;
-    amount: string | null;
-  }[];
-  /** True when the rental is newly listed ("Neu" badge). The live search summary
-   *  feed carries no listing-age signal — the SDK's search result
-   *  (`toSearchOutputItem`) exposes only id/name/timeZone/address/images/
-   *  highlights/formattedTotal, with no created/published/firstListed field — so
-   *  this is always false today and the badge self-hides; wire it to a real SDK
-   *  source (e.g. a per-rental created/published date) when search exposes one.
-   *  Never fabricate it — straight-through rule. */
-  isNew: boolean;
-  /** `property.id`, verbatim (null when the rental belongs to no property). The
-   *  v-office "Property" is the Anlage/complex a rental sits in; the home page's
-   *  Anlage cards link to `/suchen?property=<id>`, and the shared search store
-   *  scopes its snapshot to this id client-side (the live search has no property
-   *  filter key — verified: `property=` lands in `unusedFilterKeys`). Same
-   *  scoping model as favorites mode. */
-  propertyId: string | null;
-  /** `location`, verbatim (null when the feed omits coordinates). */
-  coords: {
-    lat: number;
-    lng: number;
+interface ExtraBase extends ValueConstraints {
+  /** Input name: `[a-z][a-zA-Z0-9]*`, unique, not a `ContactFieldName`. */
+  readonly extra: string;
+  /** The field's label (also the default title of its message line). */
+  readonly label: string;
+  /** Default false. A required checkbox must be ticked. */
+  readonly required?: boolean;
+  /** What the value is titled inside the message; default `label`. */
+  readonly messagePrefix?: string;
+  /** The control's placeholder. Default none. */
+  readonly placeholder?: string;
+  /** Default "full" ("half" pairs two fields on wide screens). */
+  readonly width?: FieldWidth;
+  /** Text fields: the starting text; select: an option value; checkbox: "true" ticks it. */
+  readonly defaultValue?: string;
+  /** Fill from this URL query parameter (`prefillFromParams`). Text, number, date and select extras
+   *  only; built-in fields are personal data, and a URL is logged and shared. */
+  readonly prefillParam?: string;
+}
+/** A field the contact API has no slot for. Its answer becomes one line of the message:
+ *    text/multiline/email/tel/number  "<prefix>: <value>" (only when answered)
+ *    date                             "<prefix>: <formatIsoDate(value)>"
+ *    select                           "<prefix>: <option label>"
+ *    checkbox                         "<prefix>: <checkboxYes|checkboxNo>", ALWAYS written (both answers
+ *                                     are worth having to the reader in the PMS)
+ *    period                           "<prefix>: <from> <periodSeparator> <to>" (a missing end is
+ *                                     `periodOpen`), or "<prefix>: <periodFlexible>" */
+type ExtraFieldSpec = (ExtraBase & {
+  readonly kind?: "text" | "multiline" | "email" | "tel" | "number" | "date";
+}) | (ExtraBase & {
+  readonly kind: "select";
+  readonly options: readonly SelectOption[];
+}) | (ExtraBase & {
+  readonly kind: "checkbox";
+}) | (ExtraBase & {
+  readonly kind: "period";
+  /** Offer "dates are flexible" (the dates then do not count). Default false. */
+  readonly allowFlexible?: boolean;
+});
+/** One entry of a form's field list, in render order:
+ *    "email"                         the built-in as it ships
+ *    { field: "phone", required }    a built-in with one decision changed
+ *    { extra: "amount", kind, … }    a field the API has no slot for
+ *    { group: "Objekt" }             an inert heading over the fields that follow */
+type ContactFieldSpec = ContactFieldName | BuiltInFieldSpec | ExtraFieldSpec | {
+  readonly group: string;
+};
+/** A period answer: ISO days or "" each. */
+interface PeriodValue {
+  /** Arrival, or "" while not chosen. */
+  readonly from: IsoDay | "";
+  /** Departure, or "" while not chosen (an open end). */
+  readonly to: IsoDay | "";
+  /** The visitor ticked "dates are flexible": the dates do not count. */
+  readonly flexible: boolean;
+}
+/** Text-like fields hold a string, a checkbox a boolean, a period a `PeriodValue`. */
+type ContactValue = string | boolean | PeriodValue;
+/** Every field's value by input name. */
+type ContactValues = Readonly<Record<string, ContactValue>>;
+/** Every string the rules read; the merged `ContactFormCopy` of the components satisfies it.
+ *  Templates: `{label}` the field label, `{email}` the support inbox, `{max}` the limit. */
+interface ContactFormMessages {
+  /** The salutation field's label. */
+  salutationLabel: string;
+  /** The forename field's label. */
+  forenameLabel: string;
+  /** The surname field's label. */
+  surnameLabel: string;
+  /** The email field's label. */
+  emailLabel: string;
+  /** The phone field's label. */
+  phoneLabel: string;
+  /** The country field's label. */
+  countryLabel: string;
+  /** The street field's label. */
+  streetLabel: string;
+  /** The postal code field's label. */
+  postalCodeLabel: string;
+  /** The city field's label. */
+  cityLabel: string;
+  /** The message field's label. */
+  messageLabel: string;
+  /** A required salutation left empty. */
+  salutationRequired: string;
+  /** A required forename left empty. */
+  forenameRequired: string;
+  /** A required surname left empty. */
+  surnameRequired: string;
+  /** A required email left empty. */
+  emailRequired: string;
+  /** A required phone left empty. */
+  phoneRequired: string;
+  /** A required country left empty. */
+  countryRequired: string;
+  /** A required street left empty. */
+  streetRequired: string;
+  /** A required postal code left empty. */
+  postalCodeRequired: string;
+  /** A required city left empty. */
+  cityRequired: string;
+  /** A required message left empty. */
+  messageRequired: string;
+  /** An extra left empty ("Bitte {label} ausfüllen."). */
+  extraRequired: Template<"label">;
+  /** A present value that fails a declared constraint ("Bitte {label} prüfen."). */
+  fieldInvalid: Template<"label">;
+  /** A present email that is no address. */
+  emailInvalid: string;
+  /** A period whose end precedes its start, or whose start lies in the past. */
+  periodInvalid: string;
+  /** The composed message exceeds the API limit ({max}). */
+  messageTooLong: Template<"max">;
+  /** The line above the button when the SDK rejected fields that are marked inline. */
+  fixMarkedFields: string;
+  /** The fallback failure line; contains {email}. */
+  sendFailed: Template<"email">;
+  /** The fallback failure line when the site publishes no inbox (`supportEmail: null`). */
+  sendFailedNoEmail: string;
+  /** A ticked checkbox extra in the message line ("ja"). */
+  checkboxYes: string;
+  /** An unticked checkbox extra in the message line ("nein"). */
+  checkboxNo: string;
+  /** A period extra answered with "dates are flexible". */
+  periodFlexible: string;
+  /** A period extra's missing end in the message line. */
+  periodOpen: string;
+  /** Between a period's two days in the message line ("bis"). */
+  periodSeparator: string;
+}
+/** The control a field renders. "salutation" and "country" are the two selects whose options the
+ *  UI resolves itself (copy labels; the build-time country register). */
+type ContactControl = "text" | "multiline" | "email" | "tel" | "number" | "date" | "select" | "checkbox" | "period" | "salutation" | "country";
+/** A spec after defaults: what validation, payload and render all walk, so they cannot disagree
+ *  about what the form contains. */
+type ResolvedContactItem =
+/** An inert heading over the fields that follow (`{ group }` in the spec list). */
+{
+  readonly type: "group";
+  readonly label: string;
+} | {
+  readonly type: "field";
+  /** The input name (a built-in's name or the extra's). */
+  readonly name: string;
+  /** The built-in it fills, or null for an extra. */
+  readonly builtIn: ContactFieldName | null;
+  /** The control to render. */
+  readonly control: ContactControl;
+  /** The label shown (the spec's, else the copy's). */
+  readonly label: string;
+  /** Whether an empty value stops the submit. */
+  readonly required: boolean;
+  /** "full" or "half" on wide screens. */
+  readonly width: FieldWidth;
+  /** The `autocomplete` token of a built-in (personal data the browser may fill), or null. */
+  readonly autoComplete: string | null;
+  /** The control's placeholder, or null. */
+  readonly placeholder: string | null;
+  /** A select extra's options; null for every other control. */
+  readonly options: readonly SelectOption[] | null;
+  /** The salutation choices in order; null for every other control. */
+  readonly salutations: readonly Salutation[] | null;
+  /** A period extra offers "dates are flexible". */
+  readonly allowFlexible: boolean;
+  /** Extras: the title of its message line; null for built-ins. */
+  readonly messagePrefix: string | null;
+  /** The value rules judged on a present value. */
+  readonly constraints: ValueConstraints;
+  /** The URL query parameter that fills it (extras only), or null. */
+  readonly prefillParam: string | null;
+};
+/** A resolved field (the non-group member of `ResolvedContactItem`). */
+type ResolvedContactField = Extract<ResolvedContactItem, {
+  readonly type: "field";
+}>;
+/** What a contact form is built from; plain data except the clock. */
+interface ContactFormOptions {
+  /** The SDK locale of the request and the language of its validation messages. */
+  readonly locale: Locale;
+  /** Recorded on the request in the PMS; names the channel ("Anfrage Eigentümer"). ≤ 200 characters. */
+  readonly subject: string;
+  /** The field list in render order. */
+  readonly fields: readonly ContactFieldSpec[];
+  /** Every string the rules read (the components' merged copy satisfies it). */
+  readonly messages: ContactFormMessages;
+  /** Named in the failure line. Required, no default: a default would print one agency's inbox on
+   *  another's site. `null` drops that half of the line (no publishable inbox). */
+  readonly supportEmail: string | null;
+  /** Prefill (`prefillFromParams`) and the preselected country (`detectCountry`); laid over the
+   *  fields' own defaults. */
+  readonly initialValues?: ContactValues;
+  /** The clock for "today" constraints and periods, for tests. Default `() => new Date()`. */
+  readonly now?: () => Date;
+}
+/** editing → submitting → sent (or back to editing on a failure). */
+type ContactPhase = "editing" | "submitting" | "sent";
+/** What a UI renders. */
+interface ContactFormState {
+  /** The resolved field list (groups and fields), in render order. */
+  readonly items: readonly ResolvedContactItem[];
+  /** Every field's current value by input name. */
+  readonly values: ContactValues;
+  /** Field name → message, in list order; set by submit, by blur (email format) and by SDK issues. */
+  readonly errors: Readonly<Record<string, string>>;
+  /** Where the form stands. */
+  readonly phase: ContactPhase;
+  /** The line above the button after a failed submit (summary, unmapped SDK issues, or the
+   *  send-failed fallback). */
+  readonly submitError: string | null;
+  /** The first failed field after a failed submit; the UI focuses it once per `nonce`, after the
+   *  render that marks it (so the error is announced with the field). */
+  readonly focusTarget: {
+    readonly name: string;
+    readonly nonce: number;
   } | null;
+  /** `contactSpecProblems(fields)`: reported once by the UI (console.warn), never thrown. */
+  readonly specProblems: readonly string[];
 }
-export interface SearchPayload {
-  items: SearchResultItem[];
-  /** Stay length from the user's start/end query, or null when undated. */
-  nights: number | null;
-  /** Count of SDK-provided alternative-period results in this page. */
-  alternativePeriodCount: number;
-  /** `pageInfo.nextCursor`, verbatim — opaque, passed straight back to fetch
-   *  the next page. null when the feed omits it (last page / no more). */
-  cursor: string | null;
-  /** `pageInfo.hasNextPage`, verbatim. */
-  hasNextPage: boolean;
-}
-export interface LiveSearchOptions {
-  /** Path of the site's rental detail pages, prefixed to every result `href`
-   *  before the slug (e.g. `/de/unterkuenfte`). A trailing slash is tolerated.
-   *  Default: `DEFAULT_RENTALS_PATH`. */
-  rentalsPath?: string | undefined;
-}
-/** The rental detail pages' path when the caller names none — the site
- *  starter's German route. A site whose pages live elsewhere (a locale prefix,
- *  another segment) passes its own `rentalsPath` to `runLiveSearch`. */
-export declare const DEFAULT_RENTALS_PATH = "/unterkuenfte";
-/**
- * Run a live search for the given URL query string (e.g.
- * `window.location.search`). Builds the SDK query from the picker params,
- * calls the rate-limited live API once, and maps the items. Pass an SDK
- * instance to reuse its internal cache across an eager pagination walk;
- * otherwise this function owns a short-lived instance for a single call.
- *
- * Pass `cursor` (the previous page's `pageInfo.nextCursor`, treated as
- * opaque) to fetch the next page. The returned `cursor`/`hasNextPage` are
- * the SDK's `pageInfo` straight through, so the caller can keep paging.
- *
- * `options.rentalsPath` is the path the site serves its rental detail pages
- * under — the part of every result `href` before the slug. Routing is the
- * site's decision (a locale prefix like `/de/unterkuenfte`, another segment),
- * so it arrives as an option the way `SearchBar.action` and `Quote.checkoutPath`
- * do; `locale` never implies it. Defaults to `DEFAULT_RENTALS_PATH`.
- */
-export declare function runLiveSearch(sdk: VofficeSdk, searchString: string, locale: Locale, cursor?: string | null, options?: LiveSearchOptions): Promise<SearchPayload>;
+/** What `submit()` resolves to. `rejected` = the SDK refused the input (issues routed); `failed` =
+ *  transport, backend or a lazy SDK that did not load. */
+type ContactSubmitOutcome = {
+  readonly ok: true;
+} | {
+  readonly ok: false;
+  readonly reason: "busy" | "invalid" | "rejected" | "failed";
+};
+/** The actions a UI calls; stable for the form's lifetime. */
+interface ContactFormActions {
+  /** Typing or choosing: sets a value; a shown error of that field is re-judged. */
+  setValue(name: string, value: ContactValue): void;
+  /** Leaving a field: re-checks the email format; clears that field's shown error once it is fixed. */
+  blur(name: string): void;
+  /** Validate, compose, submit. USER-initiated only. A second call while submitting resolves
+   *  `{ ok: false, reason: "busy" }` (double click, second Enter). */
+  submit(): Promise<ContactSubmitOutcome>;
+  /** Back to the initial values and `editing` ("send another message"). */
+  reset(): void;
+  /** Copy, locale, subject or inbox changed (props of the UI); values are kept. The fields and the
+   *  SDK source are read from the first options only. */
+  update(options: Partial<Pick<ContactFormOptions, "messages" | "locale" | "subject" | "supportEmail">>): void;
+  /** Stop publishing: later actions and a still pending submit change nothing. */
+  dispose(): void;
+}
+/** The contact form store: its state and its actions. */
+type ContactForm = Store<ContactFormState> & ContactFormActions;
+/** The contact form store. The SDK source may be lazy (`loadSharedSdk`): it is awaited on the first
+ *  submit only, so a contact page ships no SDK until someone sends a message. */
+type CreateContactForm = (sdk: SdkSource, options: ContactFormOptions) => ContactForm;
+/** See {@link CreateContactForm}. */
+export declare const createContactForm: CreateContactForm;
 //#endregion
-//#region src/sort.d.ts
-/** URL param. A client-side scope like `property`/`region`, NOT an SDK query
- *  key — it is dropped from the SDK query string in search.ts's DROP_KEYS and
- *  travels as the separate `sort` input instead. */
-export declare const SORT_PARAM = "sort";
-export type SortValue = "empfohlen" | "preis-auf" | "preis-ab";
-/** The backend's own order. Emits no `sort` at all, so it is exactly the
- *  ordering the page has always shown. Typed as the literal (not `SortValue`)
- *  so `value === DEFAULT_SORT` narrows the rest away for `SDK_SORT`. */
-export declare const DEFAULT_SORT: "empfohlen";
-export interface SortOption {
-  value: SortValue;
-  label: string;
-  /** Needs a period + occupancy, or the SDK rejects it before transport. */
-  pricedOnly?: boolean;
+//#region src/forms/contact-fields.d.ts
+/** The contact kit's set without its owner-location field (a site that wants one adds an extra). */
+export declare const DEFAULT_CONTACT_FIELDS: readonly ContactFieldName[];
+/** The API rejects an empty value for these (`validateContactSubmitInput`); `subject` comes from the
+ *  options, and `message` may be composed from extras alone. */
+export declare const CONTACT_ENDPOINT_REQUIRED: readonly ("salutation" | "surname" | "email" | "country" | "message")[];
+/** The API's length limits a form can exceed by composition (extras ride in the message). */
+export declare const CONTACT_LIMITS: {
+  readonly message: 5000;
+  readonly subject: 200;
+};
+/** Specs → items, labels from `messages` unless the spec sets one. Validation, the payload and the
+ *  render all walk this one list. */
+type ResolveContactFields = (fields: readonly ContactFieldSpec[], messages: ContactFormMessages) => readonly ResolvedContactItem[];
+/** Problems that make every submit fail or the form ambiguous, as developer-facing sentences: a
+ *  missing or optional endpoint-required built-in (`message` may be absent only when an extra always
+ *  writes a line: a required one or a checkbox), a duplicate name, an extra named like a built-in or
+ *  not `[a-z][a-zA-Z0-9]*`, a select without options, salutation `options` on another field, a
+ *  `prefillParam` on a checkbox or period extra (ignored), an invalid `pattern`. */
+type ContactSpecProblems = (fields: readonly ContactFieldSpec[]) => readonly string[];
+/** See {@link ResolveContactFields}. */
+export declare const resolveContactFields: ResolveContactFields;
+/** See {@link ContactSpecProblems}. */
+export declare const contactSpecProblems: ContactSpecProblems;
+//#endregion
+//#region src/forms/contact-issues.d.ts
+/** Issues with a path onto a PRESENT built-in become field errors (`title`→salutation,
+ *  `address.countryCode`→country, `address.streetAndHousenumber`→street,
+ *  `address.postalCode`→postalCode, `address.city`→city, the rest by name). Issues on fields the form
+ *  does not render, or without a path, join `submitError` (an invisible field error helps nobody).
+ *  Without issues: `sendFailed` with {email}, or `sendFailedNoEmail` when the site has no inbox.
+ *  `reason` is "rejected" when the SDK sent issues, else "failed". */
+type RouteContactIssues = (error: unknown, items: readonly ResolvedContactItem[], messages: ContactFormMessages, supportEmail: string | null) => RoutedContactIssues;
+/** What `routeContactIssues` returns. */
+interface RoutedContactIssues {
+  /** Field name → the SDK's message, in list order. */
+  readonly errors: Readonly<Record<string, string>>;
+  /** The line above the button. */
+  readonly submitError: string;
+  /** "rejected": the SDK refused the input; "failed": transport or backend. */
+  readonly reason: "rejected" | "failed";
 }
-export declare const SORT_OPTIONS: readonly SortOption[];
-/** The sort in the URL, or the default when absent/unknown. */
-export declare function activeSort(search: string): SortValue;
-/**
- * Can this query be priced? Mirrors the SDK's own precondition: a fixed period
- * (`start`+`end`) or a flexible window (`dates`/`month`/`weekend`), AND
- * occupancy. Without both, the backend returns no totals and the SDK rejects
- * price ordering before it reaches the wire.
- *
- * Period keys count only with a value: the search's `buildQuery` drops empty
- * params (`?start=&end=`), so a key that is merely present would pass this
- * gate and still reach the SDK undated. `weekend` is the exception — it is a
- * presence-only flag on both sides.
- */
-export declare function isPricedQuery(search: string): boolean;
-/** Is this option selectable for the current query? */
-export declare function isSortAvailable(option: SortOption, search: string): boolean;
-/**
- * The `sort` to hand the SDK for this URL, or `undefined` for the backend's
- * own order. Falls back to `undefined` (rather than throwing) when a price
- * sort survives in the URL after the dates were cleared.
- */
-export declare function resolveSdkSort(search: string): SearchSearchSort | undefined;
+/** See {@link RouteContactIssues}. */
+export declare const routeContactIssues: RouteContactIssues;
 //#endregion
-//#region src/filters.d.ts
-/**
- * The search filter model the UI consumes — client-safe, no SDK import. The SDK
- * exposes filter definitions via `getFilters`; a site curates them at build time
- * into `FilterDef[]` (which keys, in which order) and hands the list to the
- * results surface. Boolean filters toggle, integer filters are a lower bound.
- */
-export type FilterType = "boolean" | "int";
-export interface FilterDef {
-  /** The URL query key, which is also the SDK's search parameter key. */
-  key: string;
-  label: string;
-  type: FilterType;
-  /** Only meaningful for `int` filters. */
-  min: number;
-  max: number;
+//#region src/forms/contact-payload.d.ts
+/** The `live.contact.submit` input. The message is composed in LIST ORDER around the `message` field:
+ *  extra lines listed before it form a block above the free text, lines listed after it a block
+ *  below; lines join with "\n", blocks with "\n\n" (whoever reads it in the PMS reads the period and
+ *  the headcount first when a form lists them first). The phone is sent as typed: this endpoint does
+ *  not constrain it (the booking endpoint does, so the checkout normalizes). */
+type BuildContactInput = (items: readonly ResolvedContactItem[], values: ContactValues, context: {
+  readonly locale: Locale;
+  readonly subject: string;
+  readonly messages: ContactFormMessages;
+}) => ContactSubmitInput;
+/** See {@link BuildContactInput}. */
+export declare const buildContactInput: BuildContactInput;
+//#endregion
+//#region src/forms/contact-prefill.d.ts
+/** `prefillParam` values from a query string (the UI passes `new URLSearchParams(location.search)`):
+ *  trimmed, capped at 200 characters; a number must read as one, a date must be an ISO day, a select
+ *  value must be one of its options. The UI applies them to EMPTY fields only (a visitor may have
+ *  typed before the island hydrated); the value stays editable. */
+type PrefillFromParams = (items: readonly ResolvedContactItem[], params: URLSearchParams) => ContactValues;
+/** See {@link PrefillFromParams}. */
+export declare const prefillFromParams: PrefillFromParams;
+//#endregion
+//#region src/forms/contact-validate.d.ts
+/** Required, email format, declared constraints, periods, and the composed message length (an error
+ *  on `message`, or on the first extra when the form lists no message field). Returns field name →
+ *  message, in list order; empty when the values can be sent. */
+type ValidateContactValues = (items: readonly ResolvedContactItem[], values: ContactValues, messages: ContactFormMessages, context: {
+  readonly locale: Locale;
+  readonly subject: string;
+  readonly today: IsoDay;
+}) => Readonly<Record<string, string>>;
+/** See {@link ValidateContactValues}. */
+export declare const validateContactValues: ValidateContactValues;
+//#endregion
+//#region src/forms/events.d.ts
+/** The window CustomEvent name. Renaming it is a major. */
+export declare const CONTACT_EVENT: "voffice:contact";
+/** The event detail. Carries the channel (`subject`) and never a field value: no personal data
+ *  reaches a listener (a tracker, a consent-less script). */
+type ContactEventDetail = {
+  readonly type: "sent";
+  readonly subject: string;
+};
+//#endregion
+//#region src/legal/fetch.d.ts
+/** One legal document: the PMS's subject (the page's own heading) and its sanitized blocks. */
+interface LegalDocument {
+  /** The document's subject, as the PMS names it. */
+  readonly title: string;
+  /** The document as sanitized blocks. */
+  readonly blocks: readonly RichBlock[];
 }
-export interface ActiveFilter {
-  key: string;
-  label: string;
+/** The two documents a checkout names; null = the workspace publishes none (or an empty one). */
+interface LegalDocuments {
+  /** The terms (AGB), or null. */
+  readonly terms: LegalDocument | null;
+  /** The privacy notice, or null. */
+  readonly privacy: LegalDocument | null;
 }
-/** A boolean filter is active when its param is present and truthy. */
-export declare const isBooleanFilterActive: (value: string) => boolean;
-/**
- * The filters currently applied in the query, in the order the defs are
- * declared — the removable chips. An `int` label is prefixed with the localized
- * "minimum" wording, because its value is a lower bound.
- */
-export declare function activeFiltersFromQuery(searchParams: URLSearchParams, defs: readonly FilterDef[], minimumPrefix: string): ActiveFilter[];
-/** The dog-friendly search as the URL carries it: `pets=true` (or a count) and,
- *  from an older vocabulary, `petsCount=N`. Read by the live search. */
-export declare const PETS_PARAM = "pets";
-export declare const PETS_COUNT_PARAM = "petsCount";
-export declare function petsCountInQuery(search: string): number;
-//#endregion
-//#region src/regions.d.ts
-/**
- * The "Region" scope of the live search.
- *
- * "Region" is a v10 custom attribute (MULTI_SELECT, PUBLIC) set per rental in
- * v-office — e.g. Duhnen, Döse. The live search has no usable server-side key
- * for it: the SDK filters a custom attribute only on an exact raw match of its
- * stored JSON-array value, and registering the definition would fold a
- * `Region: ["…"]` string into every card and detail highlight (verified). So
- * `region` is dropped from the SDK query (search.ts, DROP_KEYS) and applied
- * here, client-side, against the per-rental regions the site hydrates from its
- * static catalogue at build time — the same channel as the other facts the
- * search projection does not carry.
- */
-/** URL query key carrying the active region scope. Repeatable: several
- *  `region=<name>` values OR together (show rentals in ANY selected region). */
-export declare const REGION_PARAM = "region";
-/** The regions active in a URL query string: the `region` values, trimmed,
- *  de-duplicated, order preserved. Absent or empty → `[]`. */
-export declare function activeRegions(search: string): string[];
-/**
- * The results inside the region scope. A rental may carry several regions
- * (MULTI_SELECT) and matches when any of them is selected; with no active
- * region every result stays. A rental the map does not know is outside every
- * region, so it drops out of a scoped search rather than passing unseen.
- */
-export declare function scopeToRegions<T extends {
-  id: string;
-}>(items: readonly T[], active: readonly string[], regionsByRentalId: (id: string) => readonly string[] | undefined): T[];
+/** v10: `static.documents.getTermsAndPrivacyPolicy` → `normalizeStructuredDocument` (a leading
+ *  headline that repeats the subject is dropped; the page draws its own). A document the workspace
+ *  does not publish, or whose data holds no content, is null. Throws on transport, logged with the
+ *  SDK's cause: a build never silently ships a checkout whose terms it could not read. v9: both null
+ *  without a call, until the SDK serves the hub's documents (CMS-1122). */
+type FetchLegalDocuments = (sdk: WebsiteSdk, locale: Locale) => Promise<LegalDocuments>;
+/** See {@link FetchLegalDocuments}. */
+export declare const fetchLegalDocuments: FetchLegalDocuments;
 //#endregion
-export type { CheckoutFlow, CheckoutFlowActions, CheckoutFlowApi, CheckoutFlowMessages, CheckoutFlowOptions, CheckoutFlowState, CheckoutIssue, CheckoutPart, CheckoutPhase, CountryGroupsLike, InsuranceDocsState, Locale, Stay, StructureViolation, ValidationMessages };
+export { ADJACENT_BELOW_M, ALWAYS_EXCLUDED_CATEGORIES, type ActiveFilter, type AdaptEvent, type AdaptRentalOptions, type AlternativePeriod, type AmenityGroup, type AmenityPreviewItem, type AmenityPreviewOptions, type AvailabilityWindowInput, type Backend, type BadgeRule, type BedRun, type BookableFrom, type BookingConfirmation, type BookingContact, type BookingKind, type BookingSnapshot, type BuiltInFieldSpec, type BuiltInPolicyLabels, type CampaignChip, type CampaignChipsInput, type CampaignLabelSource, type CampaignOf, type CardBadge, type CardContext, type CardFact, type CardImage, type CardLiveField, type CardMatch, type CardModelOptions, type CardPill, type CardRating, type CardSignal, type CardSource, type CardSourceExtras, type CardStatus, type CatalogueRental, type CheckedCopy, type CheckoutActions, type CheckoutBlocker, type CheckoutContext, type CheckoutEventDetail, type CheckoutFlow, type CheckoutFlowOptions, type CheckoutHandover, type CheckoutHandoverOptions, type CheckoutInsuranceState, type CheckoutIssue, type CheckoutMessages, type CheckoutPart, type CheckoutPhase, type CheckoutPolicyState, type CheckoutRequirement, type CheckoutService, type CheckoutState, type CheckoutStructure, type CheckoutVoucherState, type ChildAgeRange, type ClusterOptions, type ContactControl, type ContactEventDetail, type ContactFieldName, type ContactFieldSpec, type ContactForm, type ContactFormActions, type ContactFormMessages, type ContactFormOptions, type ContactFormState, type ContactLink, type ContactPhase, type ContactSubmitOutcome, type ContactValue, type ContactValues, type CountryCode, type CountryGroups, type CountryOption, type CountryOptionsInput, DEFAULT_CHILD_AGE, DEFAULT_CLUSTER, DEFAULT_FIT, DEFAULT_FLAG_FILTERS, DEFAULT_GUEST_LIMITS, DEFAULT_SORT_OPTIONS, type DateControls, type DateMode, type DateSearch, type DateSearchOptions, type DateSearchState, type DayKind, type DayPrices, type DayState, type DefaultFit, type DescriptionContent, type DescriptionPreview, type DistanceKind, ENHANCE_PARTS, type EmptyCause, type EndAvailability, type EndAvailabilityInput, type EnhancePart, type EnhanceParts, type EnvRecord, type ExternalSearchLink, type ExternalSearchSource, type ExtraFieldSpec, FAVORITE_LEAVE_MS, type FacetOption, type FacetOptionsOptions, type FactKind, type Favorites, type FavoritesChange, type FavoritesOptions, type FavoritesPort, type FavoritesState, type FetchRentalFlagsOptions, type FieldWidth, type FilterDef, type FilterEntry, type FilterGroupSpec, type FilterMeasurement, type FilterSelection, type FilterSpec, type FindCampaignStartOptions, type FindOfferWindowsOptions, type FitOptions, type FlexibleStay, GATE_MARKERS, GLYPHS, type GateMarkers, type Glyph, type GlyphList, type GuestBound, type GuestBounds, type GuestCaps, type GuestForm, type GuestFormField, type GuestFormOptions, type GuestFormState, type GuestKind, type GuestLimits, type GuestOptions, type GuestSearch, type GuestSearchOptions, type GuestSearchState, HIDDEN_ROOM_ATTRIBUTES, HUB_ENDPOINTS, type HistoryPort, type HubEndpointTable, type HubEndpoints, type ImplicitScope, type InitialAvailability, type InsuranceDocsState, type InsurancePaymentLink, type IsoDay, type IsoMonth, type LegalDocument, type LegalDocuments, type Listener, type LiveSearchOptions, type LngLat, type LoadRentalCatalogueOptions, type Locale, type MapBounds, type MapPlace, type MapPoint, type MapResultsSource, type MapViewReport, type OfferWindow, type OffersWindowSpec, type OptionalGuestField, type OutcomeInput, type Party, type PaymentLine, type PaymentReturn, type PaymentScheduleView, type PeriodLabel, type PeriodValue, type PillOptions, type PinLabelOptions, type PixelOffset, type PlaceMarker, type PlainTextOptions, type PolicyBranch, type PolicyBranchOptions, type PolicyChoiceMode, type PolicyOffer, type PolicyOfferInput, type PolicyOption, type PolicyStance, type PolicyTerms, type PolicyTermsOptions, type PolicyTitle, type PreviewStrategy, type PriceCents, type PriceLine, type PriceView, type QueryPair, type QueryShape, type QuoteAddonService, type QuoteCancellationPolicy, type QuoteCta, type QuoteEventDetail, type QuoteFlow, type QuoteFlowOptions, type QuoteFlowSettings, type QuoteFlowState, type QuoteHandover, type QuoteInsurance, type QuoteInsuranceOption, type QuoteOccupancy, type QuoteOutcome, type QuotePolicyRule, type QuoteRequest, type QuoteResult, type QuoteSelectionResult, type QuoteUnavailableCode, type QuoteView, type QuoteVoucher, type Range, type RawSearchPage, type RelatedOptions, type Relaxation, type RentalAddress, type RentalAddressMode, RentalAddressModeError, type RentalCardModel, RentalContentError, type RentalCounts, type RentalDetail, type RentalDistance, type RentalFacts, type RentalFactsMap, type RentalFlag, type RentalFlagsResult, type RentalImage, type RentalIndexEntry, type RentalMatch, type RentalMatchOptions, type RentalPropertyInfo, type RentalReview, type RentalReviews, type RentalRoom, type ResolveFiltersOptions, type ResolvedContactField, type ResolvedContactItem, type ResolvedFilters, type ResolvedSearchGroup, type ResultHandoverOptions, type ResultLinkOptions, type ResultsMapController, type ResultsMapOptions, type ResultsMapState, type ResultsMapSurface, type ReviewCriterion, type ReviewSummary, type RichBlock, type RichInline, type RoomKind, type RotationOptions, type RouteParams, type RouteTemplate, type RoutedContactIssues, SDK_ENV, SEARCH_PAGE_SIZE, SEARCH_PARAMS, SORT_URL_VALUE, STAGES, type Salutation, type SameSpotGroup, type SameSpotLayout, type SameSpotMode, type SameSpotOptions, type SanitizedSearch, type SdkConfig, type SdkConfigForInput, SdkEnvError, type SdkFilterDefinition, type SdkMode, type SdkOptions, type SdkQueryOptions, type SdkSearchQuery, type SdkSetup, type SdkSource, type SearchActions, type SearchContract, type SearchField, type SearchForm, type SearchFormIssue, type SearchFormOptions, type SearchFormState, type SearchGroupSpec, type SearchOutcome, type SearchPage, type SearchPageRequest, type SearchParamAliases, type SearchParamKeys, type SearchPeriod, type SearchQuery, type SearchResultItem, type SearchScope, type SearchScopeKind, type SearchState, type SearchStatus, type SearchStore, type SearchStoreClaim, type SearchStoreOptions, type SearchedParts, type SelectOption, type Selection, type SelectionSpec, type ShareLocation, type ShareUrlOptions, type SharedSdk, type ShowcaseGroup, type ShowcaseGroupSpec, type ShowcaseOrder, type SnapshotImage, type SortKey, type SortOptionState, type Stage, type Stay, type StayPicker, type StayPickerOptions, type StayPickerState, type StayPrice, type StayWindow, type StorageLike, type Store, type StructureRequirement, type StructureViolation, type StructuredDocumentOptions, type SubmitBookingOptions, type SubmitWording, type Template, type TextMarkup, type TokensOf, type Unsubscribe, VOFFICE_ENDPOINTS, type ValidationMessages, type ValueConstraints, type VofficeEndpointTable, type VofficeEndpoints, WATER_KINDS, type WalkOptions, type WalkSummary, type WebsiteSdk, type WhenEmpty, type WhenUnavailable, type WritableStore, type WriteSearchOptions, activeFilters, adaptRental, addDays, agesComplete, amenityPreview, assignSlugs, campaignChips, campaignGroup, cardSource, catalogueResultItem, circleOffsets, clampParty, compareUndatedSearchOrder, createResultsMapController, createSdk, createSearchStore, createStore, describeOutcome, descriptionPreview, descriptionSummary, distanceFact, distanceMeters, externalSearchHref, facetOptions, fetchRentalFlags, fetchSearchPage, findCampaignStart, findOfferWindows, formatIsoDate, formatPriceLabel, frameFor, guestBounds, handoverQuery, hasMapPoints, idsInView, isAdjacent, isIsoDay, isSpecEcho, layoutSameSpot, loadRentalCatalogue, loadRentalFacts, loadSharedSdk, mapPoints, matches, measureFilters, mergePlaces, minimumSteps, newestReviewsFirst, nightsBetween, normalizeStructuredDocument, occupancyOf, offerWindowHref, offersWindowQuery, parseCounts, parseDistances, parsePriceLabel, parseTextBlocks, partyPairs, plainText, queryShape, quickFilterDefs, rankHighlights, readParty, readSearch, readSelection, rentalAddressLine, rentalFactsMap, resolveFilters, resolveSdk, resultCardSource, resultsQueryFlagScript, routeHref, sanitizeSearch, sdkConfigFor, sdkConfigFromEnv, searchHref, shareSdk, shortReviewerName, slugify, sortFromSearch, sortResults, splitReviewAuthor, stayKeyOf, toCardModel, toSdkQuery, toSdkSort, todayIso, walkSearchPages, withRentalFacts, withoutFilter, withoutFilters, writeSearch, writeSelection };