@v-office/website-headless 0.2.0 → 1.1.0

package/dist/index-CPMXjfFH.d.mts

@@ -0,0 +1,2724 @@
+import { FilterGetFiltersOutput, Locale, RentalRentalsOutput, SearchSearchSort, WebsiteSDKConfig, WebsiteSDKOptions, createWebsiteSDK } from "@v-office/website-sdk";
+import { BackendKind } from "@v-office/website-sdk/capabilities/search";
+//#region src/enhance/parts.d.ts
+/** Every `data-part` value an engine binds, by role (the value object is declared below):
+ *  - strips (`bindStrip`): `strip` root, `strip-track` (the horizontal scroller), `strip-item`,
+ *    `strip-prev` / `strip-next`, `strip-dots` (one child per item), `strip-counter`;
+ *  - layers (`bindLayer`): `layer` (a `<dialog>`), `layer-open` (with `aria-controls` = the dialog id),
+ *    `layer-close`, `layer-body` (the inner scroller reset on close);
+ *  - reveal and clamp (`bindReveal`, `bindClamp`): `reveal`, `reveal-item`, `reveal-more`, `reveal-less`;
+ *    `clamp`, `clamp-text`, `clamp-toggle`;
+ *  - share and favorites (`bindShare`, `bindFavorites`): `share`, `share-status`, `favorite`, `favorite-badge`;
+ *  - the rental gallery (`bindGallery`): `rental-gallery` root, `rental-gallery-tile`, `rental-gallery-all`,
+ *    the `<dialog>`s `rental-gallery-grid`, `rental-gallery-viewer`, `rental-floorplan`, the per-photo
+ *    `rental-gallery-caption` / `rental-gallery-counter`, and `rental-floorplan-open`. */
+type EnhanceParts = typeof ENHANCE_PARTS;
+/** One engine part name. */
+type EnhancePart = EnhanceParts[keyof EnhanceParts];
+/** Attributes the blueprints gates read today (fact-check, room measurements). The rental blocks render
+ *  them beside their parts, on the same elements as the kits did, until the gates read parts. */
+type GateMarkers = typeof GATE_MARKERS;
+declare const ENHANCE_PARTS: {
+  readonly strip: "strip";
+  readonly stripTrack: "strip-track";
+  readonly stripItem: "strip-item";
+  readonly stripPrev: "strip-prev";
+  readonly stripNext: "strip-next";
+  readonly stripDots: "strip-dots";
+  readonly stripCounter: "strip-counter";
+  readonly layer: "layer";
+  readonly layerOpen: "layer-open";
+  readonly layerClose: "layer-close";
+  readonly layerBody: "layer-body";
+  readonly reveal: "reveal";
+  readonly revealItem: "reveal-item";
+  readonly revealMore: "reveal-more";
+  readonly revealLess: "reveal-less";
+  readonly clamp: "clamp";
+  readonly clampText: "clamp-text";
+  readonly clampToggle: "clamp-toggle";
+  readonly share: "share";
+  readonly shareStatus: "share-status";
+  readonly favorite: "favorite";
+  readonly favoriteBadge: "favorite-badge";
+  readonly gallery: "rental-gallery";
+  readonly galleryTile: "rental-gallery-tile";
+  readonly galleryAll: "rental-gallery-all";
+  readonly galleryGrid: "rental-gallery-grid";
+  readonly galleryViewer: "rental-gallery-viewer";
+  readonly galleryCaption: "rental-gallery-caption";
+  readonly galleryCounter: "rental-gallery-counter";
+  readonly floorplanOpen: "rental-floorplan-open";
+  readonly floorplan: "rental-floorplan";
+};
+declare const GATE_MARKERS: {
+  readonly stats: "data-rental-stats";
+  readonly descriptionStart: "data-rental-description";
+  readonly descriptionEnd: "data-rental-description-end";
+  readonly amenities: "data-rental-amenities";
+  readonly amenitiesModal: "data-amenities-modal";
+  readonly amenitiesEnd: "data-amenities-overlay-end";
+  readonly roomAttribute: "data-room-attr";
+  readonly reviewCard: "data-review-card";
+};
+//#endregion
+//#region src/shared/rich-text.d.ts
+/** Inline content. Text is plain (the renderer escapes it). */
+type RichInline =
+/** A run of text with its emphasis. */
+{
+  readonly type: "text";
+  readonly text: string;
+  readonly strong?: true;
+  readonly em?: true;
+  readonly code?: true;
+} |
+/** A line break inside a paragraph. */
+{
+  readonly type: "break";
+} |
+/** href already whitelisted (https, http, mailto, tel, or a site-relative `/path` or `#anchor`); any
+ *  other target became text. `external` = an http(s) URL (the renderer opens it in a new tab). */
+{
+  readonly type: "link";
+  readonly href: string;
+  readonly external: boolean;
+  readonly children: readonly RichInline[];
+};
+/** Block content. Heading levels are the document's own, clamped to 2–4; the renderer offsets them. */
+type RichBlock =
+/** A heading with text (empty headings are dropped). */
+{
+  readonly type: "heading";
+  readonly level: 2 | 3 | 4;
+  readonly children: readonly RichInline[];
+} |
+/** A paragraph with text. */
+{
+  readonly type: "paragraph";
+  readonly children: readonly RichInline[];
+} |
+/** A list; each item is its own block flow. */
+{
+  readonly type: "list";
+  readonly ordered: boolean;
+  readonly items: readonly (readonly RichBlock[])[];
+} |
+/** A horizontal rule. */
+{
+  readonly type: "rule";
+};
+/** How `parseTextBlocks` reads PMS plain text. "light": `**bold**` → strong, `- `/`* ` lines → a list,
+ *  so no asterisk reaches a guest (a stray `**` is dropped). "plain": the text verbatim. */
+type TextMarkup = "light" | "plain";
+/** Options of `normalizeStructuredDocument`. */
+interface StructuredDocumentOptions {
+  /** The document's subject: a leading heading repeating it is removed (the page draws its own). */
+  readonly title?: string;
+}
+/** Options of `plainText`. */
+interface PlainTextOptions {
+  /** Cut at a word boundary so the result, " …" included, is at most this long. Default: no cut. */
+  readonly max?: number;
+}
+/** PMS plain text → blocks: blank lines separate paragraphs, single newlines collapse to a space. */
+type ParseTextBlocks = (text: string, markup?: TextMarkup) => RichBlock[];
+/** The SDK's structured-document nodes (`static.documents`) → blocks: editor markers and context-bound
+ *  tools (`ai`, `conditional`, `snippet`, `image`, `quote`) dropped, unknown tools keep their children,
+ *  inline runs grouped into paragraphs ("\n" = break, a blank line = new paragraph), a leading heading
+ *  repeating `title` removed, empty headings dropped, non-whitelisted hrefs become text. */
+type NormalizeStructuredDocument = (nodes: readonly unknown[], options?: StructuredDocumentOptions) => RichBlock[];
+/** Plain text of blocks (markup removed, whitespace collapsed), for a meta description or an alt text. */
+type PlainText = (blocks: readonly RichBlock[], options?: PlainTextOptions) => string;
+/** See {@link ParseTextBlocks}. */
+declare const parseTextBlocks: ParseTextBlocks;
+/** See {@link NormalizeStructuredDocument}. */
+declare const normalizeStructuredDocument: NormalizeStructuredDocument;
+/** See {@link PlainText}. */
+declare const plainText: PlainText;
+//#endregion
+//#region src/rental/model.d.ts
+/** One item of `static.rentals.getRentals` — the adapter's only input. */
+type CatalogueRental = RentalRentalsOutput;
+/** A rental as the detail page renders it. */
+interface RentalDetail {
+  /** PMS rental id, verbatim. */
+  id: string;
+  /** URL slug from `assignSlugs`; search results link with the same map. */
+  slug: string;
+  /** `nameOrLabel`, verbatim (v9 property units: property + unit). */
+  name: string;
+  /** `address.city`, or undefined — no fallback town (a fallback prints a wrong place). */
+  town?: string;
+  /** The address parts the PMS states (printing the street is the site's decision). */
+  address: RentalAddress;
+  /** The coordinates the PMS publishes. */
+  coords?: {
+    lat: number;
+    lng: number;
+  };
+  /** The SDK-translated rental type ("Ferienwohnung"), verbatim; often absent on v9. */
+  type?: string;
+  /** Counts the feed states (`parseCounts`). */
+  counts: RentalCounts;
+  /** Joined by `fetchRentalFlags`; a flag the backend could not answer is absent. */
+  flags: Partial<Record<RentalFlag, boolean>>;
+  /** Distances the vicinity states, one per kind, in feed order. */
+  distances: RentalDistance[];
+  /** Photos in feed order: duplicates dropped, floor plans excluded, WebP where served. */
+  images: RentalImage[];
+  /** Images tagged `category: "floorplan"`, as an uncropped rendition, in feed order. */
+  floorplans: RentalImage[];
+  /** The PMS description: headline, intro, body and (when published) the arrival info. */
+  description: DescriptionContent;
+  /** SDK highlights (its default prioritisation), reordered by `rankHighlights`, never
+   *  dropped. Count echoes stay; consumers skip them with `isSpecEcho`. */
+  highlights: string[];
+  /** The attribute catalogue by PMS category; unsafe categories and prose items removed. */
+  amenities: AmenityGroup[];
+  /** Vicinity "Themen" / "Themes" items, verbatim. */
+  themes: string[];
+  /** Every vicinity category with the items that are not distances ("Lage": "Am Strand",
+   *  "Meerblick"), verbatim — what `{ stated }` card matching reads besides the amenities. */
+  vicinity: AmenityGroup[];
+  /** Every room the feed states, in SDK order. */
+  rooms: RentalRoom[];
+  /** The rating summary and the reviews with text. */
+  reviews: RentalReviews;
+  /** The property (Anlage) the rental belongs to, when the feed states one. */
+  property?: RentalPropertyInfo;
+}
+/** The address parts the PMS states; whether a page prints the street is the site's decision. */
+interface RentalAddress {
+  /** Street and number, verbatim. */
+  street?: string;
+  /** Postal code, verbatim. */
+  postalcode?: string;
+  /** Town, verbatim. */
+  city?: string;
+  /** Region or state, verbatim. */
+  province?: string;
+  /** Country, verbatim. */
+  country?: string;
+}
+/** Booleans `getRentals` lacks, answered by dateless live searches (`fetchRentalFlags`). */
+type RentalFlag = "petsAllowed" | "atBeach" | "inCity" | "seaView" | "lakeView" | "garage" | "indoorPool" | "garden";
+/** One photo of a rental or its property. */
+interface RentalImage {
+  /** SDK `idOrPath`; stable, usable as a key. */
+  id: string;
+  /** The image URL (WebP where served). */
+  src: string;
+  /** Responsive candidates, when the feed offers renditions. */
+  srcset?: string;
+  /** The PMS caption (`alt`, else `title`) when it says more than the rental's name. */
+  caption?: string;
+  /** Intrinsic size when the feed states it (`metadata.dataImage`). */
+  width?: number;
+  /** Intrinsic height when the feed states it. */
+  height?: number;
+  /** The rental's own photo, or one of its property's (`AdaptRentalOptions.propertyImages`). */
+  source: "rental" | "property";
+}
+/** The PMS description texts. */
+interface DescriptionContent {
+  /** PMS `description.headline`. */
+  headline?: string;
+  /** PMS `description.intro` (the short description). */
+  intro?: string;
+  /** PMS `description.description` as blocks (`intro` when the body is empty). */
+  body: RichBlock[];
+  /** PMS `description.arrivalInfo`, present only with `publishArrivalInfo: true`. */
+  arrivalInfo?: RichBlock[];
+}
+/** One PMS amenity or vicinity category with its items. */
+interface AmenityGroup {
+  /** The PMS category label ("Küche"). */
+  label: string;
+  /** Items verbatim, in SDK order ("1977 Baujahr" stays). */
+  items: string[];
+}
+/** What a room is, for its glyph. Unknown types are "other" — never a bedroom. */
+type RoomKind = "bedroom" | "bathroom" | "living" | "kitchen" | "other";
+/** One room the feed states. */
+interface RentalRoom {
+  /** PMS room type, verbatim ("Schlafzimmer", "Sonstiges"). */
+  type: string;
+  /** What the room is, for its glyph. */
+  kind: RoomKind;
+  /** 1-based position among rooms of the same type, set only when the type repeats. */
+  ordinal?: number;
+  /** PMS room description, when stated. */
+  description?: string;
+  /** Beds as runs: consecutive identical beds collapse into a count, never de-duplicated. */
+  beds: BedRun[];
+  /** Room attributes verbatim, the floor-covering family (and `hideRoomAttributes`) removed. */
+  attributes: string[];
+}
+/** Consecutive identical beds of a room. */
+interface BedRun {
+  /** PMS bed type ("Standard Bett"); may be "" after an SDK translation override. */
+  type: string;
+  /** PMS bed kind ("Einzelbett"). */
+  kind?: string;
+  /** Consecutive identical beds in this run (the SDK repeats an entry per bed). */
+  count: number;
+  /** Bed attributes verbatim. */
+  attributes: string[];
+}
+/** A rental's guest reviews. */
+interface RentalReviews {
+  /** Absent when the PMS holds no aggregate; every review UI then self-hides. */
+  summary?: ReviewSummary;
+  /** Reviews with text, newest first (`newestReviewsFirst`). */
+  items: RentalReview[];
+}
+/** The PMS's rating aggregate. */
+interface ReviewSummary {
+  /** "4.3/5" → 4.3. */
+  score: number;
+  /** "4.3/5" → 5 (5 when the feed states no scale). */
+  scale: number;
+  /** "4 Bewertungen" → 4. */
+  count: number;
+  /** The PMS's own verbal grade (its "classification"), verbatim. No grade is ever derived from the
+   *  score. */
+  grade?: string;
+  /** Per-criterion means, PMS labels verbatim (v9: the site's `v9Reviews.criteria` labels). */
+  criteria: ReviewCriterion[];
+}
+/** One rated criterion's mean. */
+interface ReviewCriterion {
+  /** The criterion, PMS label verbatim ("Sauberkeit der Unterkunft"). */
+  label: string;
+  /** Its mean on the summary's scale. */
+  value: number;
+}
+/** One guest review with text. */
+interface RentalReview {
+  /** The PMS review id, when stated (a stable key). */
+  id?: string;
+  /** The review's own score on the summary's scale, when stated. */
+  score?: number;
+  /** The review text, verbatim. */
+  text: string;
+  /** PMS review label (a title), when stated. */
+  title?: string;
+  /** "Max M."; undefined when the feed states no name or a placeholder (the UI says "Gast"). */
+  reviewer?: string;
+  /** The stay as the SDK wrote it after the name ("verreist im Mai 2025"), verbatim. */
+  stay?: string;
+}
+/** The property (Anlage) a rental belongs to. */
+interface RentalPropertyInfo {
+  /** PMS property id. */
+  id: string;
+  /** The property's name. */
+  name: string;
+  /** Its description as blocks. */
+  description: RichBlock[];
+  /** Its highlights, verbatim. */
+  highlights: string[];
+  /** Its photos. */
+  images: RentalImage[];
+}
+//#endregion
+//#region src/rental/facts.d.ts
+/** Counts the feed states. Undefined = the feed states nothing — never print a 0. */
+interface RentalCounts {
+  /** Most guests. */
+  guests?: number;
+  /** Bedrooms. */
+  bedrooms?: number;
+  /** Bathrooms. */
+  bathrooms?: number;
+  /** Total rooms ("3 Zimmer"). */
+  rooms?: number;
+  /** Living area in m². */
+  area?: number;
+}
+/** What a distance is measured to. Locale-free: the UI's copy names it. */
+type DistanceKind = "beach" | "sea" | "lake" | "city" | "ski" | "golf" | "trainStation" | "ferry" | "airport" | "shopping" | "restaurant" | "publicTransport";
+/** One distance the vicinity states, in metres. Never estimated. */
+interface RentalDistance {
+  /** What the distance is measured to. */
+  kind: DistanceKind;
+  /** The distance in metres, as stated. */
+  meters: number;
+  /** The PMS label as stated ("Entfernung zum Strand"), for a site printing its own wording. */
+  label: string;
+}
+/** Below this a distance is a statement ("Direkt am Strand"), not a number. 25, not 0 or 50:
+ *  measured on the fleet's feeds (0 was never the real boundary). */
+declare const ADJACENT_BELOW_M: 25;
+/** The "water" fact's kinds by priority — Strand > Meer > See, never city (not water). */
+declare const WATER_KINDS: readonly DistanceKind[];
+/** Counts from `roomSummary` first, then `highlights` (v9 states no `roomSummary`, so its
+ *  bathrooms come from the highlights). */
+type ParseCounts = (sources: {
+  readonly roomSummary?: readonly string[] | null | undefined;
+  readonly highlights?: readonly string[] | null | undefined;
+}) => RentalCounts;
+/** Distances the vicinity states, one per kind (the first stated wins), in feed order. Unknown
+ *  labels are ignored, never guessed. */
+type ParseDistances = (vicinity: CatalogueRental["vicinity"]) => RentalDistance[];
+/** The first stated distance of the first kind in `kinds` (default WATER_KINDS) — by priority,
+ *  never the nearest: nearest flips between lake and sea per rental and is not additive. */
+type DistanceFact = (distances: readonly RentalDistance[] | undefined, kinds?: readonly DistanceKind[]) => RentalDistance | undefined;
+/** True below `ADJACENT_BELOW_M`. */
+type IsAdjacent = (distance: RentalDistance) => boolean;
+/** A highlight that only restates a count ("4 Schlafmöglichkeiten", "61 m²"), by shape — never
+ *  by position: how many count lines lead the list differs per rental. */
+type IsSpecEcho = (label: string) => boolean;
+/** See {@link ParseCounts}. */
+declare const parseCounts: ParseCounts;
+/** See {@link ParseDistances}. */
+declare const parseDistances: ParseDistances;
+/** See {@link DistanceFact}. */
+declare const distanceFact: DistanceFact;
+/** See {@link IsAdjacent}. */
+declare const isAdjacent: IsAdjacent;
+/** See {@link IsSpecEcho}. */
+declare const isSpecEcho: IsSpecEcho;
+//#endregion
+//#region src/sdk/types.d.ts
+/** A constructed website SDK (either backend). An instance built in `SdkMode` "all-rentals-at-once"
+ *  travels under this type too; its search takes no cursor and its `mapSearch` rejects. */
+type WebsiteSdk = ReturnType<typeof createWebsiteSDK>;
+/** PMS generation (the SDK capability helpers' `BackendKind`). */
+type Backend = "v9" | "v10";
+/** Deployment stage; selects the platform's public endpoint set. */
+type Stage = "development" | "production";
+/** Every stage, in a stable order. */
+declare const STAGES: readonly Stage[];
+/**
+ * The SDK config as plain, public, JSON-serializable values. It IS the SDK's own `WebsiteSDKConfig`
+ * with `backend` explicit on v10, so every SDK field reaches the SDK — v9's optional
+ * `facilityObjectGroupRelationAttributeId` and `rentalDataAttributes` included. Built by `sdkConfigFor`
+ * or `sdkConfigFromEnv`; a site with an unusual setup (a dev proxy, a staging hub) writes the literal.
+ */
+type SdkConfig = Extract<WebsiteSDKConfig, {
+  backend: "v9";
+}> | (Exclude<WebsiteSDKConfig, {
+  backend: "v9";
+}> & {
+  readonly backend: "v10";
+});
+/** The SDK options a surface may need, as data (`translationOverrides`, `customAttributes`,
+ *  `rentalHighlightPrioritization`, …). `searchAllRentalsAtOnce` is excluded: it changes the SDK's
+ *  type and is chosen with `SdkMode`. */
+type SdkOptions = Omit<WebsiteSDKOptions, "searchAllRentalsAtOnce">;
+/** What a site hands to every surface (`src/data/sdk.ts`). Plain data: an Astro island receives it as
+ *  a prop, so pass only the options the site uses — every byte is serialized into each island. */
+interface SdkSetup {
+  /** Backend, endpoints and the public token. */
+  readonly config: SdkConfig;
+  /** SDK options; absent = the SDK's defaults. */
+  readonly options?: SdkOptions;
+}
+/** "default": paged search plus `mapSearch`. "all-rentals-at-once": `searchAllRentalsAtOnce: true`
+ *  (at most 100 rentals priced in one call, no cursor, no `mapSearch`). */
+type SdkMode = "default" | "all-rentals-at-once";
+/** What every SDK-using store takes first: an instance, or a getter (lazy, or keyed by React). A
+ *  store calls a getter once, on its first request, and again only after a failed resolve. */
+type SdkSource = WebsiteSdk | (() => WebsiteSdk | Promise<WebsiteSdk>);
+/** The instance behind a source. Call it once per call site and keep the result. */
+type ResolveSdk = (source: SdkSource) => Promise<WebsiteSdk>;
+/** See {@link ResolveSdk}. */
+declare const resolveSdk: ResolveSdk;
+//#endregion
+//#region src/shared/dates.d.ts
+/** A local calendar day, YYYY-MM-DD. */
+type IsoDay = string;
+/** A calendar month, YYYY-MM (the URL spells it MM-YYYY). */
+type IsoMonth = string;
+/** A real calendar day in YYYY-MM-DD ("2026-02-30" is not). */
+type IsIsoDay = (value: unknown) => value is IsoDay;
+/** Today in the visitor's timezone (`now` is injected in tests). */
+type TodayIso = (now?: Date) => IsoDay;
+/** `day` moved by `days` calendar days (negative goes back). Throws a RangeError for a non-ISO day. */
+type AddDays = (day: IsoDay, days: number) => IsoDay;
+/** Whole nights from `start` to `end` (negative when reversed). Throws a RangeError for a non-ISO day. */
+type NightsBetween = (start: IsoDay, end: IsoDay) => number;
+/** "2026-09-01" → "01.09.2026" (de-DE) / "09/01/2026" (en-US) via Intl; non-ISO input returned unchanged. */
+type FormatIsoDate = (day: IsoDay, locale: Locale) => string;
+/** See {@link IsIsoDay}. */
+declare const isIsoDay: IsIsoDay;
+/** See {@link TodayIso}. */
+declare const todayIso: TodayIso;
+/** See {@link AddDays}. */
+declare const addDays: AddDays;
+/** See {@link NightsBetween}. */
+declare const nightsBetween: NightsBetween;
+/** See {@link FormatIsoDate}. */
+declare const formatIsoDate: FormatIsoDate;
+//#endregion
+//#region src/shared/glyphs.d.ts
+/** A glyph name. */
+type Glyph = "users" | "bed" | "bath" | "ruler" | "maximize" | "sofa" | "house" | "door" | "waves" | "sailboat" | "footprints" | "mountain" | "building" | "tractor" | "pin" | "paw" | "flame" | "droplets" | "trees" | "sun" | "armchair" | "home" | "key" | "star" | "check" | "view" | "terrace" | "balcony" | "garden" | "grill" | "fireplace" | "pool" | "sauna" | "jetty" | "kitchen" | "oven" | "microwave" | "fridge" | "freezer" | "coffee" | "kettle" | "dishwasher" | "washer" | "dryer" | "heating" | "wifi" | "tv" | "elevator" | "parking" | "garage" | "children" | "nonSmoking" | "groups" | "noGroups" | "pets" | "beach";
+/** The type of `GLYPHS` (declared below): every `Glyph`, each once, in the order of the union. */
+type GlyphList = readonly Glyph[];
+/** Every glyph name. */
+declare const GLYPHS: GlyphList;
+//#endregion
+//#region src/shared/price-label.d.ts
+/**
+ * How a formatted price string is trimmed:
+ * - "show": verbatim.
+ * - "hide-zero": drop a zero cents group only ("1.234,00 €" → "1.234 €"; "1.234,50 €" stays).
+ * - "truncate": cut the cents, never rounding up ("2.022,80 €" → "2.022 €"), so a card never shows more
+ *   than the checkout.
+ * - "round": half up to whole units ("2.022,50 €" → "2.023 €").
+ */
+type PriceCents = "show" | "hide-zero" | "truncate" | "round";
+/** The last separator followed by exactly two digits is the decimal part; exactly three trailing digits
+ *  group thousands; "CHF 1'234.50", "1,234.50 €", "120.00 EUR" read. A shape it does not recognise (no
+ *  number, two numbers, one decimal digit) is returned unchanged — never turned into a wrong figure. */
+type FormatPriceLabel = (label: string, cents: PriceCents) => string;
+/** A formatted total → a number for ordering only, or null when unreadable (never 0: 0 is a price and
+ *  would sort first). */
+type ParsePriceLabel = (label: string | null | undefined) => number | null;
+/** See {@link FormatPriceLabel}. */
+declare const formatPriceLabel: FormatPriceLabel;
+/** See {@link ParsePriceLabel}. */
+declare const parsePriceLabel: ParsePriceLabel;
+//#endregion
+//#region src/cards/match.d.ts
+/** An inclusive numeric bound; either side may be open. */
+interface Range {
+  /** Lowest value, inclusive; absent = open. */
+  min?: number;
+  /** Highest value, inclusive; absent = open. */
+  max?: number;
+}
+/** One fact a rental states or does not. */
+type CardSignal =
+/** A boolean in `CardSource.flags` ("petsAllowed", "atBeach" …); unknown or false → no match. */
+{
+  flag: string;
+} |
+/** An exact highlight, attribute or vicinity item (`highlights` ∪ `stated`), trimmed equality. */
+{
+  stated: string;
+} | {
+  guests: Range;
+} | {
+  bedrooms: Range;
+} |
+/** The feed's `rentalType`, verbatim. */
+{
+  rentalType: string;
+} |
+/** Real guest ratings only; a rental without a rating never matches. */
+{
+  rating: {
+    min?: number;
+    minReviews?: number;
+  };
+} |
+/** Exact `location` values (towns, or the district a site writes there). */
+{
+  location: readonly string[];
+} |
+/** Any of the site's region values (`CardSource.regions`). */
+{
+  region: readonly string[];
+} | {
+  ids: readonly string[];
+} |
+/** A free numeric fact (`CardSource.numbers[key]`) in a range; absent = no match. */
+{
+  number: {
+    key: string;
+  } & Range;
+};
+/** A signal or a combination: `anyOf` is the themed-row OR (flag OR vicinity item), `allOf`
+ *  the "Sauna AND Kamin" case. An empty `anyOf` matches nothing, an empty `allOf` everything. */
+type CardMatch = CardSignal | {
+  anyOf: readonly CardMatch[];
+} | {
+  allOf: readonly CardMatch[];
+};
+type Matches = (source: CardSource, match: CardMatch) => boolean;
+/** See {@link Matches}. */
+declare const matches: Matches;
+//#endregion
+//#region src/cards/model.d.ts
+/** One image as a card renders it. */
+interface CardImage {
+  /** The image URL (WebP from the build). */
+  src: string;
+  /** Responsive candidates, or null. */
+  srcset?: string | null;
+  /** null: the component fills its "{name}, Bild {n}" template (headless carries no language). */
+  alt: string | null;
+}
+/** A real guest rating summary. */
+interface CardRating {
+  /** On `scale`. */
+  value: number;
+  /** Reviews the score is the mean of. */
+  count: number;
+  /** Default 5. */
+  scale?: number;
+}
+/** A priced stay, verbatim from the SDK. */
+interface StayPrice {
+  /** `formattedTotal`: the stay total, never a per-night figure. */
+  readonly total: string;
+  /** `discount.formattedOriginalTotal` — the struck price; gates on its own field. */
+  readonly original: string | null;
+  /** Presence of the SDK discount block — the offer chip's only source. */
+  readonly discounted: boolean;
+  /** `discount.applied[].label`, the PMS's own words (never an amount). */
+  readonly offerLabels: readonly string[];
+}
+/** The concrete stay a price is for when it is not the searched dates. */
+interface StayWindow {
+  /** Arrival of the priced stay. */
+  readonly start: IsoDay;
+  /** Departure of the priced stay. */
+  readonly end: IsoDay;
+  /** Its nights, or null when the SDK states none. */
+  readonly nights: number | null;
+  /** `formatStayRange` of the window. */
+  readonly label: string;
+  /** Why it differs from the search: the guest's own dates inside a ± window, the stay the hub chose for a window, or an alternative period. */
+  readonly source: "own-dates" | "hub-chosen" | "alternative";
+}
+/** One bookable window suggested for a non-exact result, best first. */
+interface AlternativePeriod {
+  /** Arrival. */
+  readonly start: IsoDay;
+  /** Departure. */
+  readonly end: IsoDay;
+  /** Its nights, or null when the SDK states none. */
+  readonly nights: number | null;
+  /** `formatStayRange` of the window. */
+  readonly label: string;
+  /** The rental link with this window handed over. */
+  readonly href: string;
+  /** Its price, or null when the SDK priced none. */
+  readonly price: StayPrice | null;
+}
+/** The one card input: catalogue fields (build) + optional live fields (results). Plain JSON,
+ *  so it crosses an island boundary. */
+interface CardSource {
+  /** PMS rental id; keys the heart, the map marker and selection. */
+  id: string;
+  /** The rental's name. */
+  name: string;
+  /** The site's own detail URL (+ handover query on results). */
+  href: string;
+  /** The town (or the site's district line); null renders none. */
+  location?: string | null;
+  /** For `spreadBy: "street"`. */
+  street?: string | null;
+  /** The site's region values. */
+  regions?: readonly string[];
+  /** The photos, in feed order. */
+  images: readonly CardImage[];
+  /** Guests, bedrooms, bathrooms, area; absence is undefined, never 0. */
+  counts?: RentalCounts;
+  /** The PMS distances (water, centre, ski …). */
+  distances?: readonly RentalDistance[];
+  /** Pill candidates in lead order (`rankHighlights` order); may include count echoes (the
+   *  model drops them by shape). */
+  highlights?: readonly string[];
+  /** Further exact strings for `{ stated }` matching only (attribute and vicinity items). Never
+   *  rendered. */
+  stated?: readonly string[];
+  /** The owner's own labels; they always lead the pill row, outside `pills.only`, `prefer` and
+   *  `exclude` (still deduped against the badges, renamed, counted in `limit`). */
+  ownerPills?: readonly string[];
+  /** PMS booleans (`RentalFlag`) and site-derived flags (browser filters). */
+  flags?: Readonly<Record<string, boolean>>;
+  /** Multi-valued facets (region, property, room type, floor …) for facet filters and scopes. */
+  facets?: Readonly<Record<string, readonly string[]>>;
+  /** Free numeric facts the site derives (classification stars, floors …) for `minimum` filters
+   *  and `{ number }` matching; never rendered by the card. */
+  numbers?: Readonly<Record<string, number>>;
+  /** The PMS rental type, verbatim ("Ferienwohnung"). */
+  rentalType?: string | null;
+  /** The guest rating summary, or null without reviews. */
+  rating?: CardRating | null;
+  /** One editorial line (an owner's sentence). Site data, never generated. */
+  blurb?: string | null;
+  /** Where the rental is, or null (the map and the viewport filter skip it). */
+  coords?: {
+    readonly lat: number;
+    readonly lng: number;
+  } | null;
+  /** The property (Anlage) it belongs to, or null. */
+  propertyId?: string | null;
+  /** Live: the priced stay (results only). */
+  price?: StayPrice | null;
+  /** Live: the stay's nights. */
+  nights?: number | null;
+  /** Live: the concrete stay when it is not the searched dates. */
+  stay?: StayWindow | null;
+  /** A non-exact date match. */
+  alternative?: boolean;
+  /** Live: the bookable windows of a non-exact match, best first. */
+  periods?: readonly AlternativePeriod[];
+}
+/** Live-only keys of CardSource. */
+type CardLiveField = "price" | "nights" | "stay" | "alternative" | "periods";
+/** Build-time facts per rental for the results (what the live projection lacks). */
+type RentalFacts = Partial<Omit<CardSource, "id" | CardLiveField>>;
+/** Facts by rental id (`rentalFactsMap`), passed to SearchResults. */
+type RentalFactsMap = Readonly<Record<string, RentalFacts>>;
+/** A fact the card can state, in the order a site lists them. */
+type FactKind = "guests" | "bedrooms" | "bathrooms" | "area" | "distance";
+/** One fact a card states: a count, or the distance (with whether it is adjacent, under 25 m). */
+type CardFact = {
+  kind: "guests" | "bedrooms" | "bathrooms" | "area";
+  value: number;
+} | {
+  kind: "distance";
+  distance: RentalDistance;
+  adjacent: boolean;
+};
+/** A pill: a label, the distance moved to the row (`distance.as: "pill"`), or a fact a renderer
+ *  places in the row (`factStyle: "pills"` is the renderer's choice; the model lists facts). */
+type CardPill = {
+  kind: "label";
+  label: string;
+  icon: Glyph | null;
+} | {
+  kind: "distance";
+  distance: RentalDistance;
+  adjacent: boolean;
+} | {
+  kind: "fact";
+  fact: CardFact;
+};
+/** A claim over the photo, from a `BadgeRule`. */
+interface CardBadge {
+  /** The claim's text (the rule's label). */
+  label: string;
+  /** The claim's glyph, or null. */
+  icon: Glyph | null;
+}
+/** One query-relative chip by fixed priority: offer > alternative-period (exact searches only).
+ *  No "new": the search states no listing date. */
+type CardStatus = {
+  kind: "offer";
+  campaign: string | null;
+} | {
+  kind: "alternative-period";
+};
+/** How the pill row is filled: owner pills first, then the curated feed highlights. */
+interface PillOptions {
+  /** Pills at most. Default 3; 0 = no row. */
+  limit?: number;
+  /** Fill from highlights after the owner pills. Default true; false = owner pills only. */
+  fill?: boolean;
+  /** Exclusive allowlist of FEED highlights in display order, exact equality ("Backofen" is not
+   *  "Kamin/Ofen"). Owner pills are the owner's statement and always lead, outside the list. */
+  only?: readonly string[];
+  /** These feed highlights lead the feed part in this order, the rest follow in source order. */
+  prefer?: readonly string[];
+  /** Feed highlights never shown as a pill (an owner pill of the same label still shows: a graded
+   *  owner "Meerblick" replaces the feed's). */
+  exclude?: readonly string[];
+  /** Display names; matching uses the feed label ("Kamin/Ofen" → "Kamin"). */
+  rename?: Readonly<Record<string, string>>;
+  /** A glyph per feed label. Absent: text only (a glyph may not carry a meaning its label does not). */
+  glyphMap?: Readonly<Record<string, Glyph>>;
+}
+/** A photo claim from a signal the PMS states — never a distance threshold for "am Strand". */
+interface BadgeRule {
+  /** The PMS signal that earns the badge. */
+  when: CardMatch;
+  /** The badge's text. */
+  label: string;
+  /** The badge's glyph. Default none. */
+  icon?: Glyph;
+  /** One badge per group, the first rule that matches ("Meerblick" beats "Seeblick"). */
+  group?: string;
+}
+/** Behaviour options of the card model (components' RentalCardOptions extends this). */
+interface CardModelOptions {
+  /** Default ["guests", "bedrooms", "area", "distance"]; omit "distance" for "no water on the card". */
+  facts?: readonly FactKind[];
+  /** Which distance (default WATER_KINDS by priority) and where: in the facts (default) or as pill 0. */
+  distance?: {
+    prefer?: readonly DistanceKind[];
+    as?: "fact" | "pill";
+  };
+  /** false: no pill row. */
+  pills?: PillOptions | false;
+  /** Default none; `limit` default 2. */
+  badges?: {
+    rules: readonly BadgeRule[];
+    limit?: number;
+  };
+  /** Images kept, default 5; 1 = a still. */
+  maxImages?: number;
+  /** Default "hide-zero"; applies to total, original and every period price. */
+  priceCents?: PriceCents;
+  /** Default "footer": PMS offer labels in the price foot; "pills": a row of them; "badge": the
+   *  status chip names the first label instead of the generic "Angebot". */
+  offer?: "footer" | "pills" | "badge";
+}
+/** What `toCardModel` needs to know about the query, not the rental. */
+interface CardContext {
+  /** True only for an exact start+end search; gates the alternative-period chip. */
+  exactSearch?: boolean;
+}
+/** Everything a renderer draws. */
+interface RentalCardModel {
+  /** PMS rental id. */
+  id: string;
+  /** The rental's name. */
+  name: string;
+  /** The detail URL (with the handover query on results). */
+  href: string;
+  /** The location line, or null. */
+  location: string | null;
+  /** The editorial line, or null. */
+  blurb: string | null;
+  /** The photos kept (`maxImages`). */
+  images: readonly CardImage[];
+  /** The facts in the site's order, each only when stated. */
+  facts: readonly CardFact[];
+  /** The pill row, capped at `limit`. */
+  pills: readonly CardPill[];
+  /** The photo claims, capped at `badges.limit`. */
+  badges: readonly CardBadge[];
+  /** The one query-relative chip, or null. */
+  status: CardStatus | null;
+  /** The rating summary, or null. */
+  rating: CardRating | null;
+  /** `formatPriceLabel(…, priceCents)` applied; `original` is null when its formatted label equals
+   *  the formatted total (rounding made them equal — a struck price equal to the total states
+   *  nothing). */
+  price: StayPrice | null;
+  /** The priced stay's nights, or null. */
+  nights: number | null;
+  /** The concrete stay when it is not the searched dates, or null. */
+  stay: StayWindow | null;
+  /** The alternative windows, best first. */
+  periods: readonly AlternativePeriod[];
+  /** The PMS offer labels of the price, verbatim (never an amount). */
+  offerLabels: readonly string[];
+}
+type ToCardModel = (source: CardSource, options?: CardModelOptions, context?: CardContext) => RentalCardModel;
+/** See {@link ToCardModel}. */
+declare const toCardModel: ToCardModel;
+//#endregion
+//#region src/shared/routes.d.ts
+/** A route with `{slug}` and/or `{id}` tokens ("/unterkuenfte/{slug}", "/objekt/{id}/"); used verbatim,
+ *  trailing slashes kept. */
+type RouteTemplate = string;
+/** The values a template's tokens take. */
+interface RouteParams {
+  /** The rental's slug (from the catalogue pass; no runner derives one). */
+  readonly slug?: string;
+  /** The rental's id. */
+  readonly id?: string;
+}
+/** Fill a template. Throws when a token stays unfilled or empty, or is unknown (every `{…}` is a token),
+ *  or a brace is unbalanced: a wrong link must fail the build, not ship. */
+type RouteHref = (template: RouteTemplate, params: RouteParams) => string;
+/** See {@link RouteHref}. */
+declare const routeHref: RouteHref;
+//#endregion
+//#region src/cards/source.d.ts
+/** What the rental model does not know: the site's route and its own data. */
+interface CardSourceExtras {
+  /** The detail URL. One of `href` / `rentalHref` is required (throws otherwise — there is no
+   *  route default). */
+  href?: string;
+  /** Template filled with the rental's slug and id when `href` is absent ("/unterkuenfte/{slug}"). */
+  rentalHref?: RouteTemplate;
+  /** The owner's own labels: they lead the pill row, outside `pills.only` / `exclude`. */
+  ownerPills?: readonly string[];
+  /** Site-derived highlight labels (a seal synthesised from a flag), placed before the PMS's. Unlike
+   *  owner pills they are feed labels: `pills.only`, `prefer` and `exclude` place and filter them. */
+  highlights?: readonly string[];
+  /** The card's one-line description. */
+  blurb?: string;
+  /** Overrides `town` (a district, a display-name rule). */
+  location?: string;
+  /** The rental's region values (the search bar's `?region=` matches them). */
+  regions?: readonly string[];
+  /** Site-derived flags, merged over the PMS flags. */
+  flags?: Readonly<Record<string, boolean>>;
+  /** Site facets (a filter's values per facet key). */
+  facets?: Readonly<Record<string, readonly string[]>>;
+  /** Site numbers (a filter's minimum per key). */
+  numbers?: Readonly<Record<string, number>>;
+}
+/** A card source from the rental model: counts, distances, the rating summary, `stated` from the
+ *  amenity, theme and vicinity items, the (WebP) photos with their captions as alt text. */
+type CardSourceOf = (rental: RentalDetail, extras?: CardSourceExtras) => CardSource;
+/** The facts map for SearchResults, keyed by id: live keys dropped, and `images` dropped too —
+ *  every live result carries its own photos, and the map ships on every search page. */
+type RentalFactsMapOf = (sources: readonly CardSource[]) => RentalFactsMap;
+/** Live fields win where they state a value (not undefined, not null); facts fill the gaps. One
+ *  exception: non-empty `highlights` of the facts win, because the build ranked the same PMS labels
+ *  (`rankHighlights`) and a result card must show the pills its showcase card shows; the live list is
+ *  the fallback for rentals without facts. */
+type WithRentalFacts = (live: CardSource, facts: RentalFacts | undefined) => CardSource;
+/** The facts map the build wrote (`rentalFactsMap`) as JSON at `url`: the status and the shape are
+ *  checked (an object keyed by rental id), so a missing or broken file is an error, never an empty
+ *  facts set. */
+type LoadRentalFacts = (url: string) => Promise<RentalFactsMap>;
+/** See {@link CardSourceOf}. */
+declare const cardSource: CardSourceOf;
+/** See {@link RentalFactsMapOf}. */
+declare const rentalFactsMap: RentalFactsMapOf;
+/** See {@link WithRentalFacts}. */
+declare const withRentalFacts: WithRentalFacts;
+/** See {@link LoadRentalFacts}. */
+declare const loadRentalFacts: LoadRentalFacts;
+//#endregion
+//#region src/sdk/endpoints.d.ts
+/** The v10 endpoint set of one stage. */
+interface VofficeEndpoints {
+  /** GraphQL API. */
+  readonly apiEndpoint: string;
+  /** Image host the SDK builds image URLs on. */
+  readonly imageBaseUrl: string;
+  /** Full REST search endpoint. */
+  readonly searchEndpoint: string;
+}
+/** The be-on! Hub endpoint set of one stage (v9); the API URLs derive from `apiBaseUrl`. */
+interface HubEndpoints {
+  /** Origin of the Hub's GraphQL and REST APIs. */
+  readonly apiBaseUrl: string;
+  /** Image proxy the SDK builds image URLs on. */
+  readonly imageProxyBaseUrl: string;
+}
+/** The type of `VOFFICE_ENDPOINTS` (declared below): public v10 endpoints per stage. */
+type VofficeEndpointTable = Readonly<Record<Stage, VofficeEndpoints>>;
+/** The type of `HUB_ENDPOINTS` (declared below): be-on! Hub endpoints per stage. */
+type HubEndpointTable = Readonly<Record<Stage, HubEndpoints>>;
+/** The three values a site decides. */
+interface SdkConfigForInput {
+  /** Which PMS answers. */
+  readonly backend: Backend;
+  /** Which environment of it. */
+  readonly stage: Stage;
+  /** v9: the be-on key (public, origin-bound). v10: the frontend access token. */
+  readonly token: string;
+}
+/** Backend + stage + token → a full `SdkConfig` with the platform's endpoints. Extras are spread on top
+ *  by the caller: `{ ...sdkConfigFor(…), facilityObjectGroupRelationAttributeId: 18962 }`. */
+type SdkConfigFor = (input: SdkConfigForInput) => SdkConfig;
+/** Public v10 endpoints per stage. */
+declare const VOFFICE_ENDPOINTS: VofficeEndpointTable;
+/** be-on! Hub endpoints per stage (https only). */
+declare const HUB_ENDPOINTS: HubEndpointTable;
+/** See {@link SdkConfigFor}. */
+declare const sdkConfigFor: SdkConfigFor;
+//#endregion
+//#region src/sdk/env.d.ts
+/** The env names the fleet (kit lineage) and the platform builder use, plus the optional `CMS_STAGE`. */
+declare const SDK_ENV: {
+  /** "v9" or "v10". Required: there is no silent default. */
+  readonly backend: "CMS_BACKEND";
+  /** Optional. Set it ("development" | "production") to use the platform endpoints instead of the URL
+   *  variables. */
+  readonly stage: "CMS_STAGE";
+  /** v9 (be-on! Hub). */
+  readonly v9: {
+    readonly token: "HUB_API_KEY";
+    readonly graphqlUrl: "HUB_GRAPHQL_URL";
+    readonly v0ApiBaseUrl: "HUB_V0_API_BASE_URL";
+    readonly v1ApiBaseUrl: "HUB_V1_API_BASE_URL";
+    readonly imageProxyBaseUrl: "IMAGE_PROXY_BASE_URL";
+  };
+  /** v10. */
+  readonly v10: {
+    readonly token: "VOFFICE_LOCAL_DEV_ACCESS_TOKEN";
+    readonly apiEndpoint: "VOFFICE_API_ENDPOINT";
+    readonly searchEndpoint: "VOFFICE_SEARCH_ENDPOINT";
+    readonly imageBaseUrl: "VOFFICE_IMAGE_BASE_URL";
+  };
+};
+/** Any env-shaped record: `import.meta.env`, `process.env`, a test literal. Only non-empty strings count
+ *  as set (Vite's boolean `DEV`/`PROD` flags are ignored). */
+type EnvRecord = Readonly<Record<string, string | boolean | undefined>>;
+/**
+ * The fleet's env names → an `SdkConfig`. Rules, in order:
+ *   1. `CMS_BACKEND` must be "v9" or "v10" — no silent default (the kits' client-side "unset reads as
+ *      v9" is a capability-gating fallback, not a construction rule).
+ *   2. The backend's token is required.
+ *   3. With `CMS_STAGE` set, the platform endpoints of that stage are used and the URL variables must be
+ *      absent (two sources for one value is an error, not a merge).
+ *   4. Otherwise every URL variable of the backend is required.
+ * Throws one `SdkEnvError` naming EVERY missing or conflicting variable at once.
+ */
+type SdkConfigFromEnv = (env: EnvRecord) => SdkConfig;
+/** The env cannot build a config. Names only: a value never reaches the message. */
+declare class SdkEnvError extends Error {
+  /** Required names that are unset. */
+  readonly missing: readonly string[];
+  /** Names that are set but unusable: a URL variable beside `CMS_STAGE`, or a value outside its
+   *  vocabulary (`CMS_BACKEND`, `CMS_STAGE`). */
+  readonly conflicting: readonly string[];
+  constructor(missing: readonly string[], conflicting: readonly string[]);
+}
+/** See {@link SdkConfigFromEnv}. */
+declare const sdkConfigFromEnv: SdkConfigFromEnv;
+//#endregion
+//#region src/sdk/create.d.ts
+/** Construct an SDK the caller owns and disposes (`await sdk.dispose()`): build-time loaders and
+ *  scripts. Browser surfaces use `shareSdk`/`loadSharedSdk`. The API is rate-limited (1 request per
+ *  second per instance), so a long-lived caller keeps ONE instance. */
+type CreateSdk = (setup: SdkSetup, mode?: SdkMode) => WebsiteSdk;
+/** See {@link CreateSdk}. */
+declare const createSdk: CreateSdk;
+//#endregion
+//#region src/sdk/share.d.ts
+/** A shared instance and the caller's claim on it. */
+interface SharedSdk {
+  /** The page's shared instance for the setup. */
+  readonly sdk: WebsiteSdk;
+  /** Drop this claim (idempotent). The instance is disposed when the last claim is released and no new
+   *  claim arrived within the same task (a React StrictMode remount reuses it). */
+  release(): void;
+}
+/** Claim the page's instance for (setup, mode) — keyed by stable JSON, so key order in `setup` does not
+ *  matter and different options or modes get different instances. Ref-counted. */
+type ShareSdk = (setup: SdkSetup, mode?: SdkMode) => SharedSdk;
+/** See {@link ShareSdk}. */
+declare const shareSdk: ShareSdk;
+//#endregion
+//#region src/sdk/load.d.ts
+/** `shareSdk` with the website SDK imported on first call (a dynamic `import()`), so a page whose only
+ *  SDK use is a submit (contact) ships no SDK code up front. Resolves to the same instance `shareSdk`
+ *  holds for an equal (setup, mode). */
+type LoadSharedSdk = (setup: SdkSetup, mode?: SdkMode) => Promise<SharedSdk>;
+/** See {@link LoadSharedSdk}. */
+declare const loadSharedSdk: LoadSharedSdk;
+//#endregion
+//#region src/sdk/search-pages.d.ts
+/** Results per request. Below the v9 hub's per-request price cap of 128 (positions 0–127 were measured
+ *  priced at limit 1000, the rest unpriced), and constant within a walk because the v9 cursor is a page
+ *  number at this size. */
+declare const SEARCH_PAGE_SIZE: 100;
+/** The SDK's raw answer for one page (callers map it). */
+type RawSearchPage = Awaited<ReturnType<WebsiteSdk["live"]["search"]["search"]>>;
+/** One search, as every page of a walk repeats it. */
+interface SearchPageRequest {
+  /** The query string exactly as the SDK takes it (callers clean it: `toSdkQuery`, or a one-key probe). */
+  readonly query: string;
+  /** Language of the PMS strings in the answer. */
+  readonly locale: Locale;
+  /** The backend's ordering; absent = the backend's own. A field sort is v10 only. */
+  readonly sort?: SearchSearchSort;
+  /** v10 only: server-side id restriction. A v9 request carrying it is refused (the v9 hub has no id
+   *  filter; the caller filters the items itself). */
+  readonly rentalIdsIn?: readonly string[];
+  /** The mode the SDK was created in (pass the same value as to `createSdk` / `shareSdk`): "all-rentals-at-once"
+   *  is one call, no cursor, no limit. Default "default". */
+  readonly sdkMode?: SdkMode;
+}
+/** Limits of one walk. */
+interface WalkOptions {
+  /** Stop after this many pages and report `truncated`. Default: no cap — a walk is never silently cut. */
+  readonly maxPages?: number;
+  /** Abort between pages; the walk rejects with the signal's reason. */
+  readonly signal?: AbortSignal;
+}
+/** How a walk ended. */
+interface WalkSummary {
+  /** Pages requested. */
+  readonly pages: number;
+  /** The backend had more pages than the walk read (`maxPages` reached, or a next page without a cursor). */
+  readonly truncated: boolean;
+}
+/** One request (limit `SEARCH_PAGE_SIZE` unless `sdkMode` is "all-rentals-at-once"). A failure is logged through
+ *  `logSdkFailure("search.search")` and rethrown. */
+type FetchSearchPage = (sdk: WebsiteSdk, request: SearchPageRequest, cursor?: string | null) => Promise<RawSearchPage>;
+/** Every page in order, strictly sequentially (the SDK's queue rate-limits; two requests in flight would
+ *  only queue). Stops when the backend reports no next page, or at `maxPages`. */
+type WalkSearchPages = (sdk: WebsiteSdk, request: SearchPageRequest, options?: WalkOptions) => AsyncGenerator<RawSearchPage, WalkSummary>;
+/** See {@link FetchSearchPage}. */
+declare const fetchSearchPage: FetchSearchPage;
+/** See {@link WalkSearchPages}. */
+declare const walkSearchPages: WalkSearchPages;
+//#endregion
+//#region src/rental/adapt.d.ts
+/** How one catalogue rental becomes a `RentalDetail`. */
+interface AdaptRentalOptions {
+  /** The locale `getRentals` ran with: decides the month names the review order reads. */
+  locale: Locale;
+  /** From `assignSlugs`. */
+  slug: string;
+  /** From `fetchRentalFlags`; omitted flags stay absent. */
+  flags?: Partial<Record<RentalFlag, boolean>>;
+  /** "light" (default): `**bold**` and `- `/`* ` list lines become structure, so no asterisk
+   *  reaches a guest. "plain": text verbatim. */
+  markup?: "light" | "plain";
+  /** Publish `description.arrivalInfo`. Default false: on v9 tenants this text carried key-safe
+   *  codes on every public page. Turn it on only after reading the feed. */
+  publishArrivalInfo?: boolean;
+  /** Append the property's photos after the rental's own. Default "omit". */
+  propertyImages?: "append" | "omit";
+  /** Category labels dropped from `amenities`, besides `ALWAYS_EXCLUDED_CATEGORIES`. */
+  excludeCategories?: readonly string[];
+  /** Room attribute prefixes never shown, besides `HIDDEN_ROOM_ATTRIBUTES`. */
+  hideRoomAttributes?: readonly string[];
+  /** Patterns no published string may match. A match throws `RentalContentError` naming the
+   *  rental id and the field — never the matched text, which may be a secret. */
+  forbid?: readonly RegExp[];
+  /** Build-time notes. Default: one `console.warn` per kind and process. */
+  report?: (event: AdaptEvent) => void;
+}
+/** A build-time note of the adapter (nothing a guest sees). */
+type AdaptEvent =
+/** The feed listed the same photo more than once (v9 `.jpg`/`.jpeg`, extensionless copies). */
+{
+  kind: "duplicate-images";
+  rentalId: string;
+  dropped: number;
+} |
+/** A floor plan URL had no `rs:fill` rendition to rewrite; it may render cropped. */
+{
+  kind: "floorplan-not-rewritten";
+  rentalId: string;
+} |
+/** A review's stay month did not read in `locale`; the feed's order was kept. */
+{
+  kind: "review-order-kept";
+  rentalId: string;
+};
+/** Thrown when a published string matches `forbid`. */
+declare class RentalContentError extends Error {
+  /** The rental whose content matched. */
+  readonly rentalId: string;
+  /** Model path of the offending string, e.g. "amenities[3].items[2]". */
+  readonly field: string;
+  constructor(rentalId: string, field: string);
+}
+type AdaptRental = (raw: CatalogueRental, options: AdaptRentalOptions) => RentalDetail;
+/** See {@link AdaptRental}. */
+declare const adaptRental: AdaptRental;
+//#endregion
+//#region src/rental/amenities.d.ts
+/** Category labels (de-DE and en-US) never published: DESCRIPTION repeats prose, SEO metadata
+ *  and arrival instructions; SYSTEM holds codes. */
+declare const ALWAYS_EXCLUDED_CATEGORIES: readonly string[];
+/** One row of the amenity preview: a highlight, a distance fact, or the dog flag. */
+type AmenityPreviewItem = {
+  kind: "highlight";
+  label: string;
+} | {
+  kind: "distance";
+  distance: RentalDistance;
+} |
+/** The rental's `petsAllowed` flag is true (the UI says "Hunde willkommen"). */
+{
+  kind: "pets";
+};
+/** What the amenity preview shows. */
+interface AmenityPreviewOptions {
+  /** Ranked highlights (count echoes skipped), or a cross-section of the categories
+   *  (⌈count / groups⌉ from each, in order). Default "highlights". */
+  from?: "highlights" | "categories";
+  /** Rows at most. Default 8; 0 → no rows. */
+  count?: number;
+  /** Facts that lead the rows when the rental states them. Default []. */
+  lead?: readonly ("distance" | "pets")[];
+  /** Kinds the leading distance may state, by priority. Default WATER_KINDS. */
+  distanceKinds?: readonly DistanceKind[];
+}
+/** The preview rows and `total` — every item of the catalogue (what "all amenities" opens). */
+type AmenityPreview = (rental: RentalDetail, options?: AmenityPreviewOptions) => {
+  items: AmenityPreviewItem[];
+  total: number;
+};
+/** See {@link AmenityPreview}. */
+declare const amenityPreview: AmenityPreview;
+//#endregion
+//#region src/rental/rooms.d.ts
+/** Room attribute prefixes never shown: the floor covering ("Art des Bodens: Laminat") decides
+ *  nothing and spends a slot (a fleet decision). Prefixes, because the values are open-ended. */
+declare const HIDDEN_ROOM_ATTRIBUTES: readonly string[];
+//#endregion
+//#region src/rental/catalogue.d.ts
+/** German transliteration (ä→ae, ß→ss), other diacritics stripped, lowercase, hyphenated,
+ *  ≤ 60 characters. URL generation, not content. */
+type Slugify = (name: string) => string;
+/** Deterministic, collision-free slugs in id order (a colliding slug gets the first 6 id
+ *  characters, then the whole id); `overrides` (rental id → slug) win, e.g. a template's fixed
+ *  short slugs, and throw when two of them collide. Search results must link with this map. */
+type AssignSlugs = (rentals: readonly Pick<CatalogueRental, "id" | "nameOrLabel">[], options?: {
+  readonly overrides?: Readonly<Record<string, string>>;
+}) => Map<string, string>;
+/** Which flags `fetchRentalFlags` answers, and in which language it searches. */
+interface FetchRentalFlagsOptions {
+  /** The search locale. */
+  locale: Locale;
+  /** Flag → the dateless live-search key that answers it. Default `DEFAULT_FLAG_FILTERS`. */
+  filters?: Partial<Record<RentalFlag, string>>;
+}
+/** The three flags every backend answers on most tenants (`pets`, `locBeach`, `locCity`). A
+ *  site adds keys its tenant supports (seaView → its filter key), never a distance stand-in. */
+declare const DEFAULT_FLAG_FILTERS: Readonly<Partial<Record<RentalFlag, string>>>;
+/** The flags per rental, and the flags the tenant cannot answer. */
+interface RentalFlagsResult {
+  /** Per rental of the baseline: `true` matched, `false` did not; ignored flags are absent. */
+  byRental: ReadonlyMap<string, Partial<Record<RentalFlag, boolean>>>;
+  /** Flags the tenant cannot answer: the key came back in `unusedFilterKeys`, on v9 the match
+   *  equals the unfiltered baseline (the hub ignores an unknown key and returns everything — one
+   *  once marked all 41 rentals "at the beach"; v10 reports such a key in `unusedFilterKeys`, so a
+   *  flag every rental has stays true there), or the search failed (logged) or stopped before its
+   *  last page. No rental carries an ignored flag. */
+  ignored: RentalFlag[];
+}
+/** BUILD TIME. One unfiltered baseline + one dateless `<key>=true` search per flag, sequential,
+ *  every page walked. Fails soft: a failed search ignores its flag (a failed baseline every
+ *  flag) and never fails the build. */
+type FetchRentalFlags = (sdk: WebsiteSdk, options: FetchRentalFlagsOptions) => Promise<RentalFlagsResult>;
+/** Labels on ≥ `universalShare` (default 0.9) of the portfolio move to the back, stable within
+ *  both halves: it reorders, it never drops. Portfolio-relative (no SDK option can state it).
+ *  Under ~20 rentals the share is a two-position switch — measure before moving it. */
+type RankHighlights = <T extends {
+  readonly highlights?: readonly string[];
+}>(rentals: readonly T[], options?: {
+  readonly universalShare?: number;
+}) => T[];
+/** What the build-time catalogue loader needs: the adapter's options plus the flag joins and slug overrides. */
+interface LoadRentalCatalogueOptions extends Omit<AdaptRentalOptions, "slug" | "flags" | "locale"> {
+  locale: Locale;
+  /** Flag joins (`FetchRentalFlagsOptions.filters`), or false to skip them. Default
+   *  `DEFAULT_FLAG_FILTERS`. */
+  flags?: FetchRentalFlagsOptions["filters"] | false;
+  slugOverrides?: Readonly<Record<string, string>>;
+  universalShare?: number;
+}
+/** BUILD TIME. `getRentals` (one retry after 1.5 s: a cold start once answered a non-JSON
+ *  body) → flags → slugs → `adaptRental` → `rankHighlights`, sorted by name in `locale`. */
+type LoadRentalCatalogue = (sdk: WebsiteSdk, options: LoadRentalCatalogueOptions) => Promise<RentalDetail[]>;
+/** See {@link Slugify}. */
+declare const slugify: Slugify;
+/** See {@link AssignSlugs}. */
+declare const assignSlugs: AssignSlugs;
+/** See {@link FetchRentalFlags}. */
+declare const fetchRentalFlags: FetchRentalFlags;
+/** See {@link RankHighlights}. */
+declare const rankHighlights: RankHighlights;
+/** See {@link LoadRentalCatalogue}. */
+declare const loadRentalCatalogue: LoadRentalCatalogue;
+//#endregion
+//#region src/rental/text.d.ts
+/** How much of a description shows before the "more" control. */
+type PreviewStrategy =
+/** Whole blocks while they fit `budget` characters, then the crossing paragraph cut at its
+ *  last sentence end within the budget; a preview shorter than `min` takes the next sentence
+ *  end instead (never a stub). Ordinals ("im 1. Stock") and one-letter abbreviations ("z.B.",
+ *  "e.g.") are not sentence ends. Default budget 320, min 160 (measured: every preview
+ *  169–342 characters). Lists are never cut. */
+{
+  by: "sentences";
+  budget?: number;
+  min?: number;
+} |
+/** The first `count` blocks. */
+{
+  by: "paragraphs";
+  count: number;
+} |
+/** Nothing visible; everything behind the control. */
+{
+  by: "none";
+};
+/** The visible part of a description and whether there is more. */
+interface DescriptionPreview {
+  /** The visible blocks; a cut paragraph appears as its visible half. */
+  shown: RichBlock[];
+  /** Something is not shown whole. */
+  hasMore: boolean;
+}
+/** The preview of `blocks` (default `{ by: "sentences" }`). */
+type DescriptionPreviewOf = (blocks: readonly RichBlock[], strategy?: PreviewStrategy) => DescriptionPreview;
+/** Plain text for a meta description: the first paragraph of the body (no heading, rule or
+ *  list) that is not a bold-only headline (most feed texts open with `**Name – Slogan**`, which
+ *  only repeats the title; the first paragraph when every one is), markup removed, cut at a word
+ *  boundary so the text and its " …" fit `max` (default 160; `plainText`). "" when there is none. */
+type DescriptionSummary = (content: DescriptionContent, options?: {
+  readonly max?: number;
+}) => string;
+/** See {@link DescriptionPreviewOf}. */
+declare const descriptionPreview: DescriptionPreviewOf;
+/** See {@link DescriptionSummary}. */
+declare const descriptionSummary: DescriptionSummary;
+//#endregion
+//#region src/rental/reviews.d.ts
+/** Shorten a guest's name: every word but the last kept, the last cut to its initial
+ *  ("Max M.", "Erika Maria M.", "Anna-Lena P."); trailing titles skipped ("Max Probe
+ *  Dr." → "Max P."); a split double name joined ("Probe- Muster" is one surname); one word
+ *  unchanged (it cannot be told apart); the PMS placeholders ("Gastname nicht genannt") →
+ *  undefined (the UI says "Gast"). An already short name passes unchanged. */
+type ShortReviewerName = (name: string) => string | undefined;
+/** Split an SDK author string at the last comma whose tail ends in a year: the shortened name
+ *  and the stay as the SDK wrote it ("Anna Berg, verreist im Mai 2025" → { name: "Anna B.",
+ *  stay: "verreist im Mai 2025" }). Wording-agnostic, so de-DE and en-US split alike. */
+type SplitReviewAuthor = (author: string | undefined) => {
+  name?: string;
+  stay?: string;
+};
+/** Newest first by the stay month at the end of `author` (month names read through `Intl` in
+ *  `locale` — the locale `getRentals` ran with), `createdAt` within a month and for undated
+ *  items; stable. All or nothing: when any author carries a year whose month does not read in
+ *  `locale`, the feed's order is returned untouched (a half-sorted list looks deliberate). */
+type NewestReviewsFirst = <T extends {
+  author?: string;
+  createdAt?: string;
+}>(items: readonly T[], locale: Locale) => T[];
+/** See {@link ShortReviewerName}. */
+declare const shortReviewerName: ShortReviewerName;
+/** See {@link SplitReviewAuthor}. */
+declare const splitReviewAuthor: SplitReviewAuthor;
+/** See {@link NewestReviewsFirst}. */
+declare const newestReviewsFirst: NewestReviewsFirst;
+//#endregion
+//#region src/search/items.d.ts
+/** One rental in the result list. Strings verbatim from the SDK. */
+interface SearchResultItem {
+  /** The rental id. */
+  readonly id: string;
+  /** facts.name or nameOrLabel, trimmed. */
+  readonly name: string;
+  /** facts.location or address.city; "" when neither (a fallback place asserts nothing). */
+  readonly location: string;
+  /** facts.href (build-time, collision-free) else `rentalHref` filled, + the handover query
+   *  (`handoverQuery(search, { stay, offerLabels })`). */
+  readonly href: string;
+  /** The same rental page with the party but no dates ("other dates": the guest picks). */
+  readonly hrefWithoutDates: string;
+  /** WebP-rewritten where the host serves it (until the SDK emits WebP itself). */
+  readonly images: readonly CardImage[];
+  /** facts first, then counts read from the highlights. */
+  readonly counts: RentalCounts;
+  /** The feed's highlights, whole (the card model removes spec echoes by shape). */
+  readonly highlights: readonly string[];
+  /** The SDK's translated rental type, else the facts'. */
+  readonly rentalType: string | null;
+  /** Null when the feed priced nothing (an undated search, an unpriced hit). */
+  readonly price: StayPrice | null;
+  /** The stay the price is for when it is not simply the searched dates. */
+  readonly stay: StayWindow | null;
+  /** Non-exact result (alternatives bucket); framed as "alternative" only on exact searches. */
+  readonly alternative: boolean;
+  /** Every window the backend suggested, best first; [] on exact matches. */
+  readonly periods: readonly AlternativePeriod[];
+  /** facts.propertyId wins (v9 never sends one, v10 unreliably), else the item's property. */
+  readonly propertyId: string | null;
+  /** The item's location, else facts.coords; null keeps it off the map. */
+  readonly coords: {
+    readonly lat: number;
+    readonly lng: number;
+  } | null;
+  /** From the facts only (the search feed carries no reviews). */
+  readonly rating: CardRating | null;
+}
+/** How result links are built and which build-time facts join the live items. */
+interface ResultLinkOptions {
+  /** Template with {slug} (slugify(name)) or {id}, for rentals the facts give no href. Required:
+   *  routing is the site's knowledge, never implied by the locale. */
+  readonly rentalHref: RouteTemplate;
+  /** Build-time facts by rental id (they fill what the live projection lacks). */
+  readonly facts?: RentalFactsMap;
+  /** The language of the stay labels and of the PMS strings asked for. */
+  readonly locale: Locale;
+}
+/** A catalogue rental as a result item for a server-rendered listing: the same fields the live
+ *  items take, no price, no stay, a link without booking context (there is no search to carry). */
+type CatalogueResultItem = (rental: RentalDetail, options: ResultLinkOptions) => SearchResultItem;
+/**
+ * The order an undated search with no sort returns, as far as a build can reproduce it, so the
+ * island's swap over a prerendered list moves nothing: numeric id ascending for v9 (all-digit
+ * ids), UTF-16 code unit order for v10 (a plain `<`; `localeCompare` folds case and misorders
+ * these ids). Measured, not a contract — the island keeps the server list's order on the bare URL.
+ */
+type CompareUndatedSearchOrder = (a: {
+  readonly id: string;
+}, b: {
+  readonly id: string;
+}) => number;
+/** The card input for one result: live fields from the item, catalogue fields from the facts
+ *  (live wins). `nights` is the item's own stay length; the page-level `QueryShape.nights`
+ *  answers for exact matches of the searched dates. */
+type ResultCardSource = (item: SearchResultItem, facts?: RentalFacts) => CardSource;
+/** See {@link CatalogueResultItem}. */
+declare const catalogueResultItem: CatalogueResultItem;
+/** See {@link CompareUndatedSearchOrder}. */
+declare const compareUndatedSearchOrder: CompareUndatedSearchOrder;
+/** See {@link ResultCardSource}. */
+declare const resultCardSource: ResultCardSource;
+//#endregion
+//#region src/map/points.d.ts
+/** A coordinate pair in MapLibre order. */
+type LngLat = readonly [lng: number, lat: number];
+/** West-south and east-north corners. */
+type MapBounds = readonly [sw: LngLat, ne: LngLat];
+/** One result on the map. */
+interface MapPoint {
+  /** The rental id (the card carries the same in `data-result-card`). */
+  readonly id: string;
+  /** The result's coordinates. */
+  readonly at: LngLat;
+  /** Pin text; null = dot. */
+  readonly label: string | null;
+  /** The total as a number, for ordering only (cheapest first in a same-spot circle); never shown. */
+  readonly sortValue: number | null;
+}
+/** How a pin states the price: the same decision the cards take. */
+interface PinLabelOptions {
+  /** "hidden": every pin is a dot (a no-price ruling). Default "total". */
+  readonly price?: "total" | "hidden";
+  /** Default "hide-zero" (the cards' default). */
+  readonly cents?: PriceCents;
+}
+/** Mappable results in result order; items without coords skipped (never a guessed pin). */
+type MapPoints = (items: readonly SearchResultItem[], options?: PinLabelOptions) => MapPoint[];
+/** At least one result can be pinned (the map's and the mobile map pill's condition). */
+type HasMapPoints = (items: readonly {
+  readonly coords: unknown;
+}[]) => boolean;
+/** See {@link MapPoints}. */
+declare const mapPoints: MapPoints;
+/** See {@link HasMapPoints}. */
+declare const hasMapPoints: HasMapPoints;
+//#endregion
+//#region src/map/same-spot.d.ts
+/** "fan" (default): 2–5 pins cascade like a fanned deck (13 px / 9 px steps); 6 or more sit on a
+ *  circle, so every pin keeps its own position (a capped cascade stacked four of ten pins on one
+ *  offset: "of ten clicks the preview opens three times"). "group": 3 or more collapse into one
+ *  count bubble that fans out on a circle when clicked; pairs stay two offset pins (bubbling pairs
+ *  hid prices to solve few stacks). For single-building portfolios. */
+type SameSpotMode = "fan" | "group";
+/** A pixel offset `[x, y]` (y down). */
+type PixelOffset = readonly [x: number, y: number];
+/** A collapsed spot in "group" mode. */
+interface SameSpotGroup {
+  /** Stable while the member set is unchanged. */
+  readonly key: string;
+  /** The spot's first pin's coordinates. */
+  readonly at: LngLat;
+  /** Cheapest first (by `sortValue`), then result order. */
+  readonly ids: readonly string[];
+}
+/** Where each pin sits. */
+interface SameSpotLayout {
+  /** Offset per rental id for pins drawn individually. Absent = true position. */
+  readonly offsets: Readonly<Record<string, PixelOffset>>;
+  /** "group" mode only; empty in "fan" mode. */
+  readonly groups: readonly SameSpotGroup[];
+}
+/** The mode and the measured pin width. */
+interface SameSpotOptions {
+  /** "fan" or "group" (see `SameSpotMode`). */
+  readonly mode: SameSpotMode;
+  /** Measured width of the widest pin body in px (a dot is 20). Sizes the circles. */
+  readonly pinWidthPx: number;
+}
+/** Haversine distance in metres. */
+type DistanceMeters = (a: LngLat, b: LngLat) => number;
+/** Offsets of `count` pins on a circle that does not let them touch: radius = max(38,
+ *  (pinWidthPx + 12) · count / 2π), first pin at 12 o'clock, clockwise. */
+type CircleOffsets = (count: number, pinWidthPx: number) => PixelOffset[];
+/** Group by real distance and lay each spot out. Pure; same input, same output. */
+type LayoutSameSpot = (points: readonly MapPoint[], options: SameSpotOptions) => SameSpotLayout;
+/** See {@link DistanceMeters}. */
+declare const distanceMeters: DistanceMeters;
+/** See {@link CircleOffsets}. */
+declare const circleOffsets: CircleOffsets;
+/** See {@link LayoutSameSpot}. */
+declare const layoutSameSpot: LayoutSameSpot;
+//#endregion
+//#region src/map/frame.d.ts
+/** How the camera fits the pins. */
+interface FitOptions {
+  /** px around the fitted pins. Default 56. */
+  readonly padding?: number;
+  /** Never zoom closer than this when fitting (a lone pin). Default 12. */
+  readonly maxZoom?: number;
+  /** Leave far-away pins out of the FIRST FRAME (they stay on the map): a point farther than 10×
+   *  the median distance to the median centre, from 4 points up. Default true. */
+  readonly excludeOutliers?: boolean;
+}
+/** The default framing (padding 56, maxZoom 12, outliers excluded). */
+type DefaultFit = typeof DEFAULT_FIT;
+/** The bounds the camera fits, or null when there is nothing to frame. */
+type FrameFor = (points: readonly MapPoint[], options?: FitOptions) => MapBounds | null;
+/** Ids of the points inside `bounds` (edges included), in point order. */
+type IdsInView = (points: readonly MapPoint[], bounds: MapBounds) => string[];
+declare const DEFAULT_FIT: Required<FitOptions>;
+/** See {@link FrameFor}. */
+declare const frameFor: FrameFor;
+/** See {@link IdsInView}. */
+declare const idsInView: IdsInView;
+//#endregion
+//#region src/store/store.d.ts
+/** Receives the new state after every change. */
+type Listener<S> = (state: S) => void;
+/** Stops a listener from receiving further states. Calling it twice is harmless. */
+type Unsubscribe = () => void;
+/** Read-only view every store exposes. */
+interface Store<S> {
+  /** The current state; the same reference until the next change. */
+  getState(): S;
+  /** Called with each new state; not called for the state that is current at subscription. */
+  subscribe(listener: Listener<S>): Unsubscribe;
+}
+/** A store its owner can write; `setState` with the same reference is a no-op. */
+interface WritableStore<S> extends Store<S> {
+  /** Replace the state (or derive it from the previous one) and notify every listener. */
+  setState(next: S | ((prev: S) => S)): void;
+}
+/** A store holding `initial` until its owner writes. `S` is never a function itself: `setState` reads a
+ *  function argument as the updater form. */
+type CreateStore = <S>(initial: S) => WritableStore<S>;
+/** See {@link CreateStore}. */
+declare const createStore: CreateStore;
+//#endregion
+//#region src/guests/party.d.ts
+/** The travelling party. `adults` 0 means none chosen yet (a search sends the
+ *  default); `childrenAges[i]` is null while child i has no age. */
+interface Party {
+  /** Adults (from 18); 0 = none chosen. */
+  adults: number;
+  /** Children inside the child-age band. */
+  children: number;
+  /** One entry per child, in order; null = not chosen yet. */
+  childrenAges: readonly (number | null)[];
+  /** Children younger than the child-age band. */
+  babies: number;
+  /** Dogs. */
+  pets: number;
+}
+/** The four party types a stepper edits. */
+type GuestKind = "adults" | "children" | "babies" | "pets";
+/** Stepper maxima; 0 = the type is not offered; pets 1 = a yes/no choice. */
+interface GuestLimits {
+  /** Most adults. */
+  adults: number;
+  /** Most children. */
+  children: number;
+  /** Most babies. */
+  babies: number;
+  /** Most dogs. */
+  pets: number;
+}
+/** The kit limits every site ran on; a site overrides single keys. */
+declare const DEFAULT_GUEST_LIMITS: Readonly<GuestLimits>;
+/** Selectable child ages; younger is a baby. */
+interface ChildAgeRange {
+  /** Youngest child age (a younger child is a baby). */
+  min: number;
+  /** Oldest child age (older travels as an adult). */
+  max: number;
+}
+/** The kit's child-age band. */
+declare const DEFAULT_CHILD_AGE: Readonly<ChildAgeRange>;
+/** A rental's caps (booking contexts). Precedence: availability (maxPersons/maxAdults) > catalogue maxGuests
+ *  (used only where availability states none: v9) > limits. A stated cap above the limit wins (a 20-person house). */
+interface GuestCaps {
+  /** From availability: binds adults + children. */
+  readonly maxPersons?: number | null;
+  /** From availability: binds adults. */
+  readonly maxAdults?: number | null;
+  /** The catalogue's sleeping capacity; binds adults + children only where `maxPersons` states none (v9). */
+  readonly maxGuests?: number | null;
+  /** From availability (v9): false when the rental takes no children, babies included. */
+  readonly childrenAllowed?: boolean | null;
+  /** From availability (v9): the most dogs the quote accepts, 0 for none; null states no limit. */
+  readonly maxPets?: number | null;
+  /** false: no dog can be ADDED; a count that arrived (URL) can be lowered, never raised, and is still sent —
+   *  the flag is unreliable on several feeds, so the guest's declared party is never changed silently. */
+  readonly petsAllowed?: boolean;
+}
+/** The per-surface guest options (SearchBar `guests`, Quote `guests`, Booking `guests`). */
+interface GuestOptions {
+  /** Overrides single limits of `DEFAULT_GUEST_LIMITS`. */
+  readonly limits?: Partial<GuestLimits>;
+  /** Default `DEFAULT_CHILD_AGE`. */
+  readonly childAge?: ChildAgeRange;
+  /** Adults when none is chosen / the URL states none. Default 2 (one site: 1). */
+  readonly defaultAdults?: number;
+}
+/** What one stepper may do. */
+interface GuestBound {
+  /** false: render no control for this type. */
+  readonly offered: boolean;
+  /** Lowest count (adults 1, everything else 0). */
+  readonly min: number;
+  /** Highest count. */
+  readonly max: number;
+}
+/** One bound per party type. */
+type GuestBounds = Readonly<Record<GuestKind, GuestBound>>;
+/** Bounds for `party` (pass it as it will be sent: adults resolved). Adults win a shared person cap: children
+ *  get what the adults leave, so an overfull handover drops children, never adults. Clamp an edit against the
+ *  bounds of the party BEFORE the edit: without the pets flag the dogs that arrived are the ceiling. */
+type GuestBoundsFor = (party: Party, input: {
+  readonly limits?: Partial<GuestLimits>;
+  readonly caps?: GuestCaps;
+}) => GuestBounds;
+/** Clamp offered types to the bounds (pets per the GuestCaps rule); a not-offered type keeps its value, and
+ *  adults 0 (none chosen) stays 0. Ages follow the children count (trimmed, or padded with null). */
+type ClampParty = (party: Party, bounds: GuestBounds) => Party;
+/** Every child has an age (the age prices the stay). */
+type AgesComplete = (party: Party) => boolean;
+/** Dates + party as one comparable string (quote/checkout supersession). */
+type StayKeyOf = (stay: {
+  readonly start: IsoDay;
+  readonly end: IsoDay;
+  readonly party: Party;
+}) => string;
+/** The occupancy the SDK's quote and search take (0.1.x `QuoteOccupancy`, moved here). */
+interface QuoteOccupancy {
+  /** Adults. */
+  adults: number;
+  /** Children. */
+  children: number;
+  /** The chosen ages only; absent when none is chosen. */
+  childrenAges?: number[] | undefined;
+  /** Babies. */
+  babies: number;
+  /** Dogs. */
+  pets: number;
+}
+/** SDK occupancy; unchosen ages left out (the flows block on them). */
+type OccupancyOf = (party: Party) => QuoteOccupancy;
+/** See {@link GuestBoundsFor}. */
+declare const guestBounds: GuestBoundsFor;
+/** See {@link ClampParty}. */
+declare const clampParty: ClampParty;
+/** See {@link AgesComplete}. */
+declare const agesComplete: AgesComplete;
+/** See {@link StayKeyOf}. */
+declare const stayKeyOf: StayKeyOf;
+/** See {@link OccupancyOf}. */
+declare const occupancyOf: OccupancyOf;
+//#endregion
+//#region src/url/params.d.ts
+/** Every key of the funnel's wire format. Public: links live in bookmarks, indexes and mails. Renaming one
+ *  is a major. */
+interface SearchParamKeys {
+  /** Arrival (YYYY-MM-DD); on a ± or night-range search the window's first day. */
+  readonly start: "start";
+  /** Departure (YYYY-MM-DD); on a ± or night-range search the window's last day. */
+  readonly end: "end";
+  /** v10 ± window, `DD-MM-YYYY,DD-MM-YYYY`. */
+  readonly dates: "dates";
+  /** Stay length beside `dates` or `month`. */
+  readonly nights: "nights";
+  /** A flexible month, `MM-YYYY`, repeatable (v10). */
+  readonly month: "month";
+  /** The weekend flag beside `month` (written `weekend=1`, sent bare). */
+  readonly weekend: "weekend";
+  /** Shortest stay inside a start/end window. */
+  readonly minNights: "minNights";
+  /** Longest stay inside a start/end window. */
+  readonly maxNights: "maxNights";
+  /** The ± step the guest chose; UI-only, never sent to the SDK (restores the stay losslessly). */
+  readonly flex: "flex";
+  /** Adults. */
+  readonly adults: "adults";
+  /** Children. */
+  readonly children: "children";
+  /** Child ages, one comma list aligned to `children` (an unchosen age is empty). */
+  readonly childrenAges: "childrenAges";
+  /** Babies. */
+  readonly babies: "babies";
+  /** Search pages write the dog count as petsCount … */
+  readonly petsCount: "petsCount";
+  /** … rental and checkout pages as pets (an integer); legacy search links carry it as a flag. */
+  readonly pets: "pets";
+  /** A region scope, repeatable, OR-combined, applied in the browser. */
+  readonly region: "region";
+  /** A property (Anlage) scope. */
+  readonly property: "property";
+  /** The results ordering. */
+  readonly sort: "sort";
+  /** An offer campaign scope. */
+  readonly campaign: "campaign";
+  /** The cancellation rate chosen on the rental page (rental → checkout). */
+  readonly policy: "policy";
+  /** A booking kind handed to the checkout. */
+  readonly kind: "kind";
+  /** The payment-return marker on the checkout page. */
+  readonly return: "return";
+  /** An offer label carried from a result to the rental page, repeatable. */
+  readonly offer: "offer";
+}
+/** How long a flexible stay is: the backend's weekend flag, seven nights, or the days of the earliest month. */
+type FlexibleStay = "weekend" | "week" | "month";
+/** A search period by meaning; `writeSearch` spells it per backend. */
+type SearchPeriod =
+/** Arrive `start`, leave `end`. URL: start + end. */
+{
+  readonly kind: "exact";
+  readonly start: IsoDay;
+  readonly end: IsoDay;
+} |
+/** The guest's own stay (`start`–`end`), widened by `days` on each side, its length held.
+ *  v10: dates=DD-MM-YYYY,DD-MM-YYYY + nights + flex. v9: widened start/end + minNights = maxNights + flex.
+ *  Lower bound clamped to the floor, upper never (lossless restore from end − flex). */
+{
+  readonly kind: "plusMinus";
+  readonly start: IsoDay;
+  readonly end: IsoDay;
+  readonly days: number;
+} |
+/** Any stay of minNights..maxNights nights inside the window start–end. URL: start + end + the pair. */
+{
+  readonly kind: "nightRange";
+  readonly start: IsoDay;
+  readonly end: IsoDay;
+  readonly minNights: number;
+  readonly maxNights: number;
+} |
+/** v10 only: repeated month=MM-YYYY + weekend=1 | nights=7 | nights=<days of the earliest month>. */
+{
+  readonly kind: "flexible";
+  readonly months: readonly IsoMonth[];
+  readonly stay: FlexibleStay;
+};
+/** One `[key, value]` pair of a query string, in order. */
+type QueryPair = readonly [key: string, value: string];
+/** A search URL read into meaning. */
+interface SearchQuery {
+  /** null: no period this backend can run (a stale month/dates link on v9 reads as null). */
+  readonly period: SearchPeriod | null;
+  /** null: no party key at all. adults 0 = none chosen. */
+  readonly party: Party | null;
+  /** `region` values: trimmed, de-duplicated, in URL order. */
+  readonly regions: readonly string[];
+  /** Every other pair in URL order (filters, property, sort, campaign, site keys). Never: owned keys, flex, the
+   *  legacy pets flag, alias keys, tracking parameters, empty values. */
+  readonly carried: readonly QueryPair[];
+}
+/** Legacy keys read as a canonical one, never written; a repeatable alias value splits on commas. */
+type SearchParamAliases = Partial<Record<"start" | "end" | "region" | "adults" | "children" | "childrenAges" | "babies" | "petsCount", readonly string[]>>;
+/** The site's search contract: one `SEARCH_CONTRACT` constant, the `contract` prop of SearchBar,
+ *  SearchResults and OfferCampaignFilter (and the stores they create). */
+interface SearchContract {
+  /** Which PMS answers. Decides how a period is spelled, through the SDK's capability helpers. */
+  readonly backend: BackendKind;
+  /** Whether this backend PRICES a min/maxNights window. Default true (measured on several v9 hubs); a hub
+   *  that answers unpriced sets false: no control writes the pair, readSearch ignores it, toSdkQuery strips it. */
+  readonly nightRangeSearch?: boolean;
+  /** Always read without configuration: from→start, till→end, nights_min/nights_max, legacy pets flag. */
+  readonly aliases?: SearchParamAliases;
+}
+/** Options for writing a query. */
+interface WriteSearchOptions {
+  /** First day a ± window may reach back to. Default today. */
+  readonly floor?: IsoDay;
+  /** Adults sent when none is chosen. Default 2 (a dated v10 search without occupancy answers 200 null). */
+  readonly defaultAdults?: number;
+}
+/** URL query string (with or without `?`) → meaning. Tolerant: anything unreadable degrades to "not stated",
+ *  never to an error. `today` (default: the local date) drops flexible months already past. */
+type ReadSearch = (search: string, contract: SearchContract, today?: IsoDay) => SearchQuery;
+/** Meaning → canonical pairs, spelled for `contract.backend`, in a stable order (period, party, regions,
+ *  carried). Dogs as `petsCount` alone; a period the backend cannot spell is omitted; no empty values. A
+ *  written period always travels with adults (the chosen ones, else `defaultAdults`). */
+type WriteSearch = (query: SearchQuery, contract: SearchContract, options?: WriteSearchOptions) => QueryPair[];
+/** action (may carry a #fragment) + writeSearch. */
+type SearchHref = (action: string, query: SearchQuery, contract: SearchContract, options?: WriteSearchOptions) => string;
+/** See {@link SearchParamKeys}. */
+declare const SEARCH_PARAMS: SearchParamKeys;
+/** See {@link ReadSearch}. */
+declare const readSearch: ReadSearch;
+/** See {@link WriteSearch}. */
+declare const writeSearch: WriteSearch;
+/** See {@link SearchHref}. */
+declare const searchHref: SearchHref;
+//#endregion
+//#region src/url/party.d.ts
+/** The party from any funnel URL: petsCount wins over pets; pets=true → 1; childrenAges aligned to children (missing → null). */
+type ReadParty = (params: URLSearchParams, aliases?: SearchParamAliases) => Party | null;
+/** Party pairs in canonical order; dogs under `petsKey` (search pages: "petsCount"; rental/checkout: "pets");
+ *  zero counts omitted; childrenAges only with children (null ages written empty so the order survives). */
+type PartyPairs = (party: Party, petsKey: "petsCount" | "pets") => QueryPair[];
+/** See {@link ReadParty}. */
+declare const readParty: ReadParty;
+/** See {@link PartyPairs}. */
+declare const partyPairs: PartyPairs;
+//#endregion
+//#region src/search/filters.d.ts
+/** What a filter (build-time measurement) or a facet option (live count) that matches nothing
+ *  does: "drop" it, "disable" it (kept, not clickable), or "show" it (kept clickable). */
+type WhenEmpty = "drop" | "disable" | "show";
+/** The site's curation: which filters the results offer, grouped and ordered for this portfolio. */
+interface FilterSpec {
+  /** The panel groups, in panel order. */
+  readonly groups: readonly FilterGroupSpec[];
+  /** Keys the backend still executes but that match nothing here; stripped from every query (a
+   *  stale link must not empty the page invisibly). */
+  readonly retired?: readonly string[];
+}
+/** One titled group of the filter panel. */
+interface FilterGroupSpec {
+  /** Stable id (titles are copy and change with the language). */
+  readonly id: string;
+  /** The group heading, in the page language. */
+  readonly title: string;
+  /** The filters of the group, in panel order. */
+  readonly entries: readonly FilterEntry[];
+  /** No control, but its values are read, kept on apply, chipped and honoured. */
+  readonly hidden?: boolean;
+}
+/** One filter; where it is answered decides the kind. Every entry may be `hidden`. */
+type FilterEntry =
+/** A `getFilters` key the backend executes (boolean, or an int minimum); label/max override. */
+{
+  /** Answered by the backend. */
+  readonly kind: "sdk";
+  /** The `getFilters` query key (also the URL key). */
+  readonly key: string;
+  /** Overrides the SDK's label. */
+  readonly label?: string;
+  /** An int filter's stepper maximum (v9 often states none). */
+  readonly max?: number;
+  /** No control; the URL value is still read, chipped and honoured. */
+  readonly hidden?: boolean;
+} |
+/** Boolean answered in the browser from facts.flags[key] (a key the backend lacks or that is
+ *  dead at this hub). */
+{
+  /** Answered in the browser from the facts. */
+  readonly kind: "flag";
+  /** The URL key and the `facts.flags` key. */
+  readonly key: string;
+  /** The control label. */
+  readonly label: string;
+  /** No control; still honoured. */
+  readonly hidden?: boolean;
+} |
+/** Int lower bound from facts.counts[field], else facts.numbers[field] (a free numeric fact). */
+{
+  /** Answered in the browser from the facts. */
+  readonly kind: "minimum";
+  /** The URL key. */
+  readonly key: string;
+  /** The control label. */
+  readonly label: string;
+  /** The `facts.counts` / `facts.numbers` field compared. */
+  readonly field: string;
+  /** The stepper minimum. Default 1. */
+  readonly min?: number;
+  /** The stepper maximum. */
+  readonly max: number;
+  /** No control; still honoured. */
+  readonly hidden?: boolean;
+} |
+/** OR within the facet, from facts.facets[key] (region, property, room type, floor …). */
+{
+  /** Answered in the browser from the facts. */
+  readonly kind: "facet";
+  /** The URL key (repeatable) and the `facts.facets` key. */
+  readonly key: string;
+  /** The facet label. */
+  readonly label: string;
+  /** The values offered (`facetOptions` builds them from the facts). */
+  readonly options: readonly FacetOption[];
+  /** Several values at once (OR). Default true. */
+  readonly multiple?: boolean;
+  /** No control; still honoured. */
+  readonly hidden?: boolean;
+} |
+/** The dogs pill (occupancy `petsCount`), placed exactly where the entry sits. */
+{
+  readonly kind: "pets";
+  readonly hidden?: boolean;
+};
+/** One value of a facet; `count` = rentals carrying it (build). */
+interface FacetOption {
+  /** The URL value. */
+  readonly value: string;
+  /** The display label. */
+  readonly label: string;
+  /** Rentals carrying the value (build time). */
+  readonly count?: number;
+}
+/** The minimal shape read off `sdk.static.filter.getFilters`; its output passes as it is. */
+interface SdkFilterDefinition {
+  /** The URL / query key. */
+  readonly searchParameterQueryKey: string;
+  /** The SDK's translated label. */
+  readonly label: string;
+  /** The filter kind, every kind `getFilters` returns ("BooleanFilter", "IntFilter", "OptionFilter",
+   *  "StringFilter"). Only boolean and int filters become sdk entries; every other kind is skipped. */
+  readonly type: FilterGetFiltersOutput[number]["type"];
+  /** An int filter's bounds, when the backend states them. */
+  readonly numericBounds?: {
+    readonly min?: number;
+    readonly max?: number;
+  } | null;
+}
+/** A filter as the store and every control use it. */
+type FilterDef = {
+  /** On/off. */
+  readonly kind: "boolean";
+  /** The URL key. */
+  readonly key: string;
+  /** The control label. */
+  readonly label: string;
+  /** Who answers it: the backend, or the browser from the facts. */
+  readonly source: "sdk" | "facts";
+  /** No control (still read, chipped and honoured). */
+  readonly hidden: boolean;
+  /** Measured to match nothing and kept (`whenEmpty: "disable"`): shown, not clickable. */
+  readonly disabled: boolean;
+} | {
+  /** An int lower bound. */
+  readonly kind: "minimum";
+  /** The URL key. */
+  readonly key: string;
+  /** The control label. */
+  readonly label: string;
+  /** Who answers it. */
+  readonly source: "sdk" | "facts";
+  /** The facts field compared (facts source only). */
+  readonly field: string | null;
+  /** Stepper minimum. */
+  readonly min: number;
+  /** Stepper maximum. */
+  readonly max: number;
+  /** No control. */
+  readonly hidden: boolean;
+} | {
+  /** OR within, AND across facets. */
+  readonly kind: "facet";
+  /** The URL key (repeatable). */
+  readonly key: string;
+  /** The facet label. */
+  readonly label: string;
+  /** The values offered. */
+  readonly options: readonly FacetOption[];
+  /** Several values at once. */
+  readonly multiple: boolean;
+  /** No control. */
+  readonly hidden: boolean;
+} | {
+  readonly kind: "pets";
+  readonly hidden: boolean;
+};
+/** The curation resolved against the SDK. Serializable; computed at build, passed as a prop. */
+interface ResolvedFilters {
+  /** The visible panel, groups in order (an empty group is dropped). */
+  readonly groups: ReadonlyArray<{
+    readonly id: string;
+    readonly title: string;
+    readonly hidden: boolean;
+    readonly defs: readonly FilterDef[];
+  }>;
+  /** Every def, flat, hidden ones included (chips, round trip, matching). */
+  readonly defs: readonly FilterDef[];
+  /** Keys forwarded to the SDK. */
+  readonly sdkKeys: readonly string[];
+  /** Keys stripped from every SDK query (`FilterSpec.retired`). */
+  readonly retired: readonly string[];
+}
+/** Build-time measurement (`measureFilters`) applied while resolving. */
+interface ResolveFiltersOptions {
+  /** Hits per key against the baseline. */
+  readonly counts?: Readonly<Record<string, number>>;
+  /** The baseline total the counts were measured against. */
+  readonly total?: number;
+  /** A filter matching nothing (measured). Default "drop" (an honest filter never strands the
+   *  guest on zero). */
+  readonly whenEmpty?: WhenEmpty;
+  /** A filter matching everything does not filter (or the hub ignores it). Default "drop". */
+  readonly whenUniversal?: "drop" | "keep";
+}
+/** The working selection of the filter panel. */
+interface FilterSelection {
+  /** Boolean keys switched on. */
+  readonly booleans: ReadonlySet<string>;
+  /** Minimum per key. */
+  readonly minimums: Readonly<Record<string, number>>;
+  /** Selected values per facet key. */
+  readonly facets: Readonly<Record<string, readonly string[]>>;
+  /** Dog count; 0 = off. */
+  readonly pets: number;
+}
+/** A scope the URL carries that the search store honours without a curated facet: `?region=` (the
+ *  search bar's region field) and `?property=` (an Anlage link). */
+type ImplicitScope = "region" | "property";
+/** One applied filter, as data; the component words it from its copy table. */
+interface ActiveFilter {
+  /** Stable id: `key`, or `key=value` for one facet value. */
+  readonly id: string;
+  /** Which kind of def it came from (an implicit scope is a facet). */
+  readonly kind: "boolean" | "minimum" | "facet" | "pets";
+  /** The URL key (`petsCount` for dogs). */
+  readonly key: string;
+  /** The filter's label ("" for dogs and implicit scopes: the copy words them). */
+  readonly label: string;
+  /** Facet: the option's display label; an implicit scope's URL value verbatim (a region value, a
+   *  property id). */
+  readonly value?: string;
+  /** Minimum or dog count. */
+  readonly count?: number;
+  /** Set on an implicit scope's chip (the search store's `activeFilters` only): which scope, so the
+   *  copy can word it ("Region: {value}", "Anlage: {value}"). A curated facet for the key replaces
+   *  it, with its label and its option labels (a property's name instead of its id). */
+  readonly scope?: ImplicitScope;
+}
+/** How `facetOptions` orders its options. */
+interface FacetOptionsOptions {
+  /** Value → display label. Default: the value. */
+  readonly labels?: Readonly<Record<string, string>>;
+  /** "label" (default, locale-aware), "count-desc", or an explicit value list (unlisted values
+   *  follow by label). */
+  readonly order?: "label" | "count-desc" | readonly string[];
+  /** The collation of "label" order. Default "de-DE". */
+  readonly locale?: Locale;
+}
+/** What `measureFilters` returns. */
+interface FilterMeasurement {
+  /** Hits of the baseline query. */
+  readonly total: number;
+  /** Hits per key (a key whose count the backend does not state is absent). */
+  readonly counts: Readonly<Record<string, number>>;
+}
+/** Resolve the curation: an sdk key the SDK no longer returns self-hides, Option and String
+ *  filters in an sdk entry are skipped, int bounds default to 1..8, measured empties and
+ *  universals follow `whenEmpty`/`whenUniversal`, an empty group is dropped; hidden groups hide
+ *  their defs. Pure. */
+type ResolveFilters = (sdkFilters: readonly SdkFilterDefinition[], spec: FilterSpec, options?: ResolveFiltersOptions) => ResolvedFilters;
+/** Read the URL into a selection over every def (hidden ones included). */
+type ReadSelection = (search: string, filters: ResolvedFilters) => FilterSelection;
+/** Write a selection: every visible def's key is rewritten from the selection; hidden defs keep
+ *  their URL values; dogs as `petsCount`, never downgraded; the legacy `pets` key is deleted;
+ *  every other key stays. Returns the query without "?". */
+type WriteSelection = (search: string, filters: ResolvedFilters, selection: FilterSelection) => string;
+/** A minimum's stepper moves from `value` (0 = any): the first step up lands on the filter's floor
+ *  (`max(def.min, 1)`) and the step down from the floor returns to "any", so no value below the floor
+ *  is ever offered; `up` stops at `def.max`, `down` at 0. */
+type MinimumSteps = (def: Extract<FilterDef, {
+  kind: "minimum";
+}>, value: number) => {
+  readonly down: number;
+  readonly up: number;
+};
+/** The applied filters in def order (facets per value, hidden ones included), for chips. */
+type ActiveFilters = (search: string, filters: ResolvedFilters) => ActiveFilter[];
+/** The query without one applied filter (one facet value, or the whole key; dogs remove both
+ *  dog keys). */
+type WithoutFilter = (search: string, filter: ActiveFilter) => string;
+/** The query without every filter, hidden ones included (dates, party and scopes kept). */
+type WithoutFilters = (search: string, filters: ResolvedFilters) => string;
+/** The quick strip's defs in `keys` order: visible booleans only (a one-tap chip cannot state a
+ *  minimum); keys missing from `filters` drop out. */
+type QuickFilterDefs = (filters: ResolvedFilters, keys: readonly string[]) => FilterDef[];
+/** Facet options from the build's facts: one per distinct value, with how many rentals carry it. */
+type FacetOptions = (facts: RentalFactsMap, key: string, options?: FacetOptionsOptions) => FacetOption[];
+/** BUILD TIME, opt-in: hits per boolean key against a baseline (default "adults=1"), one
+ *  rate-limited request per key, sequential; feed the result to `resolveFilters`. A key whose
+ *  count the backend does not state is left out (never guessed as 0). */
+type MeasureFilters = (sdk: WebsiteSdk, keys: readonly string[], options: {
+  readonly locale: Locale;
+  readonly baseline?: string;
+}) => Promise<FilterMeasurement>;
+/** See {@link ResolveFilters}. */
+declare const resolveFilters: ResolveFilters;
+/** See {@link ReadSelection}. */
+declare const readSelection: ReadSelection;
+/** See {@link WriteSelection}. */
+declare const writeSelection: WriteSelection;
+/** See {@link MinimumSteps}. */
+declare const minimumSteps: MinimumSteps;
+/** See {@link ActiveFilters}. */
+declare const activeFilters: ActiveFilters;
+/** See {@link WithoutFilter}. */
+declare const withoutFilter: WithoutFilter;
+/** See {@link WithoutFilters}. */
+declare const withoutFilters: WithoutFilters;
+/** See {@link QuickFilterDefs}. */
+declare const quickFilterDefs: QuickFilterDefs;
+/** See {@link FacetOptions}. */
+declare const facetOptions: FacetOptions;
+/** See {@link MeasureFilters}. */
+declare const measureFilters: MeasureFilters;
+//#endregion
+//#region src/search/offers.d.ts
+/** An offers page's window, as portfolio facts measured by the site (never a lead-time rule). */
+interface OffersWindowSpec {
+  /** Days from today to the stay the window centres on. Required (portfolio fact). */
+  readonly startOffsetDays: number;
+  /** Stay length in nights. Required (a weekly portfolio answers 3 nights with almost nothing). */
+  readonly nights: number;
+  /** ± days around the stay. Default 14. */
+  readonly flexDays?: number;
+  /** Default 2 (a display start the guest changes in the search bar). */
+  readonly adults?: number;
+  /** Days from today the window may start at earliest ("arrive today" reads as unrealistic).
+   *  Default 1. */
+  readonly earliestArrivalOffset?: number;
+  /** An absolute first arrival day (a campaign start found at build): the window opens there and
+   *  the stay sits `flexDays` into it, so every stay it can return is a campaign stay. */
+  readonly seasonStart?: IsoDay;
+}
+/** A campaign's nearest window found by the build-time sweep (the shortcut links, the chip row). */
+interface OfferWindow {
+  /** campaignOf(label) — the group the chip names. */
+  readonly campaign: string;
+  /** Exact PMS labels seen in this window for the campaign (verbatim; never an amount). */
+  readonly labels: readonly string[];
+  /** The probed stay: check-in at the sweep offset, check-out `nights` later. */
+  readonly start: IsoDay;
+  /** Check-out, `nights` after `start`. */
+  readonly end: IsoDay;
+  /** The stay length the sweep priced. */
+  readonly nights: number;
+  /** ± days the link widens the stay by. */
+  readonly flexDays: number;
+  /** The party the link asks for. */
+  readonly adults: number;
+}
+/** The build-time sweep's grid and cost caps. */
+interface FindOfferWindowsOptions {
+  /** The language of the labels asked for. */
+  readonly locale: Locale;
+  /** Stay length probed. Required (portfolio fact). */
+  readonly nights: number;
+  /** Days from today each probe window starts at. Default [0, 90, 180, 270] (a coarse scan
+   *  grid, not a claim about the customer). */
+  readonly offsets?: readonly number[];
+  /** Window width in days per offset. Default 30. */
+  readonly spanDays?: number;
+  /** Default 2. */
+  readonly adults?: number;
+  /** ± days written into each window's link. Default 14. */
+  readonly flexDays?: number;
+  /** Pages per offset (cost cap; a capped offset is logged, never silently partial). Default 8. */
+  readonly maxPages?: number;
+  /** Default campaignGroup. */
+  readonly campaignOf?: CampaignOf;
+  /** Default today (injected for tests). */
+  readonly today?: IsoDay;
+}
+/** The season probe of one campaign. */
+interface FindCampaignStartOptions {
+  /** The language of the labels asked for. */
+  readonly locale: Locale;
+  /** The campaign group (campaignOf) whose first bookable week is wanted. */
+  readonly campaign: string;
+  /** Exact stays of this length, probed one week apart. Default 7. */
+  readonly nights?: number;
+  /** How far ahead to probe. Default 180 days. */
+  readonly horizonDays?: number;
+  /** Default 2. */
+  readonly adults?: number;
+  /** Default campaignGroup. */
+  readonly campaignOf?: CampaignOf;
+  /** Default today (injected for tests). */
+  readonly today?: IsoDay;
+}
+/** One chip of the campaign row. A campaign at home in the current window toggles `?campaign=`
+ *  in place; one at home elsewhere is a link carrying its period ("a consequence that rewrites
+ *  dates must be visible before the click"); guest-picked dates and the selected campaign always
+ *  stay toggles. No counts on chips (the page's count follows the map; a second number would
+ *  contradict it). */
+type CampaignChip = {
+  readonly kind: "toggle";
+  readonly campaign: string;
+  readonly selected: boolean;
+} | {
+  /** At home in another window: a link that also moves the dates. */
+  readonly kind: "link";
+  /** The campaign group. */
+  readonly campaign: string;
+  /** The campaign's home search (`offerWindowHref`). */
+  readonly href: string;
+  /** The home window as `formatStayRange` prints it (visible before the click). */
+  readonly period: string;
+};
+/** What `campaignChips` reads. */
+interface CampaignChipsInput {
+  /** From the store: the current search, the campaign selected, the offer labels on the results. */
+  readonly state: Pick<SearchState, "search" | "shape" | "campaign" | "offerLabels">;
+  /** findOfferWindows output (build time), may be []. */
+  readonly windows: readonly OfferWindow[];
+  /** The offers page route the links carry. */
+  readonly action: string;
+  /** The site's search contract. */
+  readonly contract: SearchContract;
+  /** The language of the period text. */
+  readonly locale: Locale;
+  /** Default campaignGroup. */
+  readonly campaignOf?: CampaignOf;
+}
+/**
+ * Strip a TRAILING percentage only, group on what remains. Joining on the customer's copy is the
+ * feed's weakness (no campaign id on `discount.applied[]`), so the rule is the narrowest that
+ * merges one campaign's discount levels: it fails by NOT grouping (two chips, visible, harmless),
+ * never by merging two campaigns (invisible, untrue). A label that is only a percentage keeps it
+ * (a chip with no name is worse than one with a number).
+ */
+type CampaignGroup = (label: string) => string;
+/**
+ * The query an offers page searches today: start/end + minNights = maxNights + flex — the ± shape
+ * both backends execute (v9 maps the pair onto the hub's nights_min/nights_max). Pinning the
+ * length is the point: the same window without the pair is priced as one long stay. The lower
+ * bound clamps to the earliest arrival, the upper never (the picker restores the stay from
+ * end − flex). Throws on a spec no window can come from (a build error, not an empty page).
+ */
+type OffersWindowQuery = (spec: OffersWindowSpec, today: IsoDay) => string;
+/**
+ * BUILD TIME, opt-in. One `walkSearchPages` per offset, sequential (cost = offsets × pages
+ * requests per build under the SDK's rate limit; a site without a campaign page does not call
+ * it); one entry per campaign at its NEAREST offset, nearest first — a later offset of the same
+ * campaign is the same campaign. [] when nothing is discounted (a nav entry then hides).
+ */
+type FindOfferWindows = (sdk: WebsiteSdk, options: FindOfferWindowsOptions) => Promise<OfferWindow[]>;
+/**
+ * BUILD TIME. The first arrival day (an exact stay of `nights`, probed one week apart) on which
+ * the campaign is offered, or null within the horizon; feeds `OffersWindowSpec.seasonStart`.
+ * Exact stays, not a window: a window answers with each rental's EARLIEST stay, which a
+ * pre-campaign week would win. Cost: one request (the first page) per week until the first hit.
+ * A failed week is logged and skipped, never read as "not running".
+ */
+type FindCampaignStart = (sdk: WebsiteSdk, options: FindCampaignStartOptions) => Promise<IsoDay | null>;
+/** The search an offer window links to — its ± window, its party, and `campaign=` — written by
+ *  the one URL writer, so the search bar reads it back as the ± stay it is. */
+type OfferWindowHref = (action: string, window: OfferWindow, contract: SearchContract) => string;
+/**
+ * The chip row, campaigns in first-seen order: what the results here carry first (toggles), then
+ * the campaigns at home elsewhere (links, nearest first). A campaign is offered once — a toggle or
+ * a link, never both. On a window the sweep found, a campaign whose home is another window links
+ * there even when a result here carries it (every chip then means "show me this campaign where it
+ * runs"); on dates the guest picked, the row only filters what they searched. Pure.
+ */
+type CampaignChips = (input: CampaignChipsInput) => CampaignChip[];
+/** See {@link CampaignGroup}. */
+declare const campaignGroup: CampaignGroup;
+/** See {@link OffersWindowQuery}. */
+declare const offersWindowQuery: OffersWindowQuery;
+/** See {@link FindOfferWindows}. */
+declare const findOfferWindows: FindOfferWindows;
+/** See {@link FindCampaignStart}. */
+declare const findCampaignStart: FindCampaignStart;
+/** See {@link OfferWindowHref}. */
+declare const offerWindowHref: OfferWindowHref;
+/** See {@link CampaignChips}. */
+declare const campaignChips: CampaignChips;
+//#endregion
+//#region src/search/outcome.d.ts
+/** What the guest set, so an empty state can say what found nothing. */
+interface SearchedParts {
+  /** Adults + children. */
+  readonly guests: number;
+  /** A period was searched. */
+  readonly dated: boolean;
+  /** A dog was searched. */
+  readonly pets: boolean;
+  /** Applied filters, facets counted per value (dogs are `pets`). */
+  readonly filters: number;
+}
+/** One way out of an empty result, as a concrete query guaranteed to differ from the current one. */
+interface Relaxation {
+  /** Which part of the search it drops. */
+  readonly kind: "without-filters" | "without-pets" | "without-dates" | "fewer-guests";
+  /** The query to navigate to (without "?"). "without-dates" removes EVERY period key. */
+  readonly search: string;
+  /** "fewer-guests": the party it offers. */
+  readonly guests?: number;
+}
+/** Why a result is empty, most actionable first (a filter is the narrower, cheaper thing to change). */
+type EmptyCause = "filters" | "pets" | "dates" | "party";
+/** The state the results area must explain instead of rendering cards. */
+type SearchOutcome = {
+  readonly kind: "error";
+} | {
+  /** Nothing to list. */
+  readonly kind: "empty";
+  /** "offers": nothing reduced in this period (normal much of the year); "ids": the page's
+   *  fixed set matched nothing. */
+  readonly scope: "search" | "favorites-none-saved" | "favorites-none-match" | "offers" | "ids";
+  /** What may have found nothing, most actionable first ([] for an empty Merkliste). */
+  readonly causes: readonly EmptyCause[];
+  /** What the guest set. */
+  readonly searched: SearchedParts;
+  /** One way out per cause. */
+  readonly relaxations: readonly Relaxation[];
+};
+/** What `describeOutcome` reads. */
+interface OutcomeInput {
+  /** The walk ended with results, or failed without any. */
+  readonly status: "ready" | "error";
+  /** Results after scopes and filters (not the map viewport: an empty map view is not an empty search). */
+  readonly visibleCount: number;
+  /** The current query. */
+  readonly search: string;
+  /** The page's resolved filters. */
+  readonly filters: ResolvedFilters | null;
+  /** The page's scope (`SearchScope`). */
+  readonly scope: "search" | "favorites" | "offers" | "ids";
+  /** Favourites scope: how many ids are saved. */
+  readonly savedCount?: number;
+}
+/** Describe an outcome; null when there are results to show. Pure. An empty Merkliste has no
+ *  causes (nothing was searched); every other empty state names its causes in order. */
+type DescribeOutcome = (input: OutcomeInput) => SearchOutcome | null;
+/** See {@link DescribeOutcome}. */
+declare const describeOutcome: DescribeOutcome;
+//#endregion
+//#region src/search/sort.d.ts
+/** recommended: backend order, no sort sent · price-asc/-desc: priced query only, sent AND
+ *  re-applied in the browser over the merged list (the SDK orders exact and alternatives
+ *  separately, which breaks at the seam) · rating, area-desc, area-asc, guests, bedrooms:
+ *  browser only, missing values last · random: browser only, seeded per page view (the v9 hub
+ *  ignores `{ by: "random" }`, v10 keeps its order). */
+type SortKey = "recommended" | "price-asc" | "price-desc" | "rating" | "area-desc" | "area-asc" | "guests" | "bedrooms" | "random";
+/** Whether an option can be chosen now, and why not. */
+interface SortOptionState {
+  /** The ordering. */
+  readonly key: SortKey;
+  /** It can be chosen for the current results. */
+  readonly available: boolean;
+  /** "needs-price": the query is not priced. "needs-data": no result carries the value. */
+  readonly reason?: "needs-price" | "needs-data";
+}
+/** The platform's short list, the same on every site that does not choose its own. */
+declare const DEFAULT_SORT_OPTIONS: readonly SortKey[];
+/** URL values, kept from the fleet's vocabulary so shared links keep working. Any known value
+ *  in the URL is honoured even when the site does not offer it in the control. */
+declare const SORT_URL_VALUE: Readonly<Record<SortKey, string>>;
+/** The sort in the URL, or "recommended" when absent or unknown (a stale value never errors). */
+type SortFromSearch = (search: string) => SortKey;
+/** The SDK ordering for a key on this query shape, or undefined (price needs a priced query: the
+ *  SDK rejects it before transport otherwise). */
+type ToSdkSort = (key: SortKey, shape: QueryShape) => SearchSearchSort | undefined;
+/** Order results; returns a new array, stable, missing values last; "recommended" keeps the
+ *  input order (it IS the backend's ordering). */
+type SortResults = <T extends SearchResultItem>(items: readonly T[], key: SortKey, seed: number) => T[];
+/** See {@link SortFromSearch}. */
+declare const sortFromSearch: SortFromSearch;
+/** See {@link ToSdkSort}. */
+declare const toSdkSort: ToSdkSort;
+/** See {@link SortResults}. */
+declare const sortResults: SortResults;
+//#endregion
+//#region src/search/query.d.ts
+/** What `sdk.live.search.search` receives for one URL query. */
+interface SdkSearchQuery {
+  /** Allowlist: period keys this backend executes, occupancy (adults, children, childrenAges,
+   *  babies, petsCount), and the resolved filters' sdk keys. Every other key is withheld (it
+   *  stays in the URL). Without "?". */
+  readonly query: string;
+  /** Present only when the backend can run the ordering for this query (price on a priced one). */
+  readonly sort?: SearchSearchSort;
+  /** Keys present and deliberately not sent (logs/tests only; nothing renders it). */
+  readonly withheld: readonly string[];
+}
+/** The site's search contract plus what the resolved filters decide. */
+interface SdkQueryOptions extends SearchContract {
+  /** The ordering in the URL (only price reaches the SDK, on a priced query). */
+  readonly sort: SortKey;
+  /** `ResolvedFilters.sdkKeys`. Absent: only period and occupancy reach the SDK. */
+  readonly sdkFilterKeys?: ReadonlySet<string>;
+  /** `FilterSpec.retired`: still executed by the backend, known to match nothing → stripped, so
+   *  an old link cannot empty the page invisibly. */
+  readonly retiredKeys?: ReadonlySet<string>;
+}
+/** What kind of search a URL is. Read by the store, the card (alternative badge, window line),
+ *  the sort control (price gate) and the outcome. Describes what the SDK is asked, so a pair
+ *  the contract strips (`nightRangeSearch: false`) does not make a window. */
+interface QueryShape {
+  /** A fixed start+end stay (not a window, not flexible): only here is a non-exact result an
+   *  "alternative" — on a window or flexible search the alternatives ARE the answer. */
+  readonly exactDates: boolean;
+  /** An executable period AND ≥ 1 adult (v9 flexible keys do not count): totals arrive, price
+   *  sort possible. */
+  readonly priced: boolean;
+  /** An executable period of any kind is present (priced or not). */
+  readonly dated: boolean;
+  /** Page-level stay length: exact → length; flexible → `nights`; pinned pair (min = max) →
+   *  that number; else null (each result states its own — a window's length is not a stay). */
+  readonly nights: number | null;
+  /** The window a night-range or v10 `dates` search spans ("bounds", not a stay), else null. */
+  readonly window: {
+    readonly start: IsoDay;
+    readonly end: IsoDay;
+  } | null;
+  /** v9 ± shape (window + pinned pair + flex): the guest's own stay, asked as a second exact
+   *  question (the hub answers a window with its EARLIEST stay); null when not this shape or
+   *  check-in is the window's first day (the second request would return the same prices). */
+  readonly ownStay: {
+    readonly start: IsoDay;
+    readonly end: IsoDay;
+  } | null;
+  /** The URL carries a real search (any key but tracking parameters). */
+  readonly hasSearch: boolean;
+}
+/** What a result link carries besides the party. */
+interface ResultHandoverOptions {
+  /** An alternative window, the hub's chosen stay, the own-date answer; else the searched dates
+   *  (with the night-range pair when they bound a window, so the quote resolves a real stay). */
+  readonly stay?: {
+    readonly start: IsoDay;
+    readonly end: IsoDay;
+  };
+  /** The result's PMS offer labels (`SearchResultItem.price.offerLabels`): written as repeated
+   *  `offer=<label>` (max 4, label text only, never an amount), and only when the link carries a
+   *  period — the Quote's `campaignLabels="from-search"` reads them back. */
+  readonly offerLabels?: readonly string[];
+}
+/** One field of the current search a partner link can carry. */
+type ExternalSearchSource = "start" | "end" | "nights" | "minNights" | "maxNights" | "adults" | "children" | "pets";
+/** A link to ANOTHER search (a partner's portal tile): `base` + one parameter per entry of
+ *  `params`, filled from the current search's shape — start/end are the window bounds on a ±
+ *  search (exact dates otherwise), nights the stay length; an entry without a value (no dates,
+ *  no party) is omitted, never written empty. */
+interface ExternalSearchLink {
+  /** Absolute https URL; may carry fixed parameters (`?region=…`). */
+  readonly base: string;
+  /** Partner parameter name → the field of the current search it carries. */
+  readonly params: Readonly<Record<string, ExternalSearchSource>>;
+  /** How start/end are spelled. Default "iso". */
+  readonly dateFormat?: "iso" | "d.m.yyyy" | "dd.mm.yyyy";
+}
+/** What `sanitizeSearch` returns. */
+interface SanitizedSearch {
+  /** The cleaned query, without "?" (the input unchanged when nothing was dropped). */
+  readonly search: string;
+  /** The keys removed. */
+  readonly dropped: readonly string[];
+}
+/**
+ * URL query → SDK input. Rules: legacy `pets` is never sent (a solo one becomes `petsCount`;
+ * with both, only `petsCount`: the SDK rejects the pair on presence); `weekend=1` → bare
+ * `weekend`; the night-range pair only as a valid pair beside start+end, never beside a flexible
+ * key, and only with `nightRangeSearch`; start/end only as a readable pair; empty values dropped.
+ * Pure: the same input always yields the same query.
+ */
+type ToSdkQuery = (search: string, options: SdkQueryOptions) => SdkSearchQuery;
+/** Classify a URL query for this contract. Pure. */
+type QueryShapeOf = (search: string, contract: SearchContract) => QueryShape;
+/** The `?…` a result link carries: the period, the party (dogs as `pets`) and the offer labels;
+ *  "" when nothing applies. */
+type HandoverQuery = (search: string, options?: ResultHandoverOptions) => string;
+/** The partner link for the current search (see `ExternalSearchLink`). Throws on a `base` that is
+ *  not an absolute URL (a wrong partner link must fail the build, not ship). */
+type ExternalSearchHref = (link: ExternalSearchLink, search: string, contract: SearchContract) => string;
+/** Drop an unsearchable stay (past start, end ≤ start, unparsable, half a pair of dates) with its
+ *  night range and `flex`, instead of an error page (the store writes it back with "replace"). */
+type SanitizeSearch = (search: string, today: IsoDay) => SanitizedSearch;
+/** Inline `<head>` script source: sets `html[data-results-query]` before first paint when the
+ *  URL carries a real search, so a prerendered listing never flashes under a search it does not
+ *  answer. Built from the one tracking list (`TRACKING_PARAM_PATTERN`). */
+type ResultsQueryFlagScript = () => string;
+/** See {@link ToSdkQuery}. */
+declare const toSdkQuery: ToSdkQuery;
+/** See {@link QueryShapeOf}. */
+declare const queryShape: QueryShapeOf;
+/** See {@link HandoverQuery}. */
+declare const handoverQuery: HandoverQuery;
+/** See {@link ExternalSearchHref}. */
+declare const externalSearchHref: ExternalSearchHref;
+/** See {@link SanitizeSearch}. */
+declare const sanitizeSearch: SanitizeSearch;
+/** See {@link ResultsQueryFlagScript}. */
+declare const resultsQueryFlagScript: ResultsQueryFlagScript;
+//#endregion
+//#region src/search/store.d.ts
+/** Narrowing of the one result set. Applied in order: ids → favourites → offers; browser filters;
+ *  requireFacts; the URL's `?campaign=`; viewport; sort. */
+interface SearchScope {
+  /** A fixed set (theme, category, Anlage, landing page), from the build. */
+  readonly ids?: readonly string[];
+  /** The guest's Merkliste. */
+  readonly favorites?: boolean;
+  /** Discounted results only; `labels` narrows to exact PMS labels; `campaign` to a whole campaign
+   *  through `campaignOf` (every percentage level of it); `window` makes the page search its offers
+   *  window when the URL carries no period (written with "replace"). A `?campaign=` in the URL
+   *  narrows further (the chip row) unless `campaign` fixes it. */
+  readonly offers?: {
+    readonly labels?: readonly string[];
+    readonly campaign?: string;
+    readonly window?: OffersWindowSpec;
+  };
+}
+/** The store's window on the browser URL, injected so headless stays DOM-free. */
+interface HistoryPort {
+  /** The current query (with or without "?"). */
+  read(): string;
+  /** "push" for a guest's choice (Back undoes it), "replace" for a sort, a sanitised query, a preset. */
+  write(search: string, mode: "push" | "replace"): void;
+  /** Back/forward and other writers; the store re-reads. */
+  subscribe(onChange: () => void): () => void;
+}
+/** The favourites store's read side; headless `Favorites` satisfies it. */
+interface FavoritesPort {
+  /** The saved rental ids. */
+  ids(): ReadonlySet<string>;
+  /** Called on every change; returns the unsubscribe. */
+  subscribe(onChange: () => void): () => void;
+}
+/** Offer label → campaign group (default `campaignGroup`). */
+type CampaignOf = (label: string) => string;
+/** Everything the page's search needs. */
+interface SearchStoreOptions extends ResultLinkOptions, SearchContract {
+  /** The page's URL (the store reads and writes the query only through it). */
+  readonly history: HistoryPort;
+  /** The page's resolved filters (build time). Absent: only period and occupancy reach the SDK. */
+  readonly filters?: ResolvedFilters | null;
+  /** The page's narrowing (fixed set, Merkliste, offers). */
+  readonly scope?: SearchScope;
+  /** The Merkliste (required for `scope.favorites`). */
+  readonly favorites?: FavoritesPort;
+  /** Default campaignGroup. */
+  readonly campaignOf?: CampaignOf;
+  /** Applied (replace) when the URL carries no search of its own (a landing page). */
+  readonly preset?: string;
+  /** Drop rentals the build has no facts for (no detail page was built). Default false. */
+  readonly requireFacts?: boolean;
+  /** "complete": nothing shows until every page is in. "first-page": the first page shows at
+   *  once; the browser sort, the outcome and the count wait for the rest. Default "complete". */
+  readonly reveal?: "complete" | "first-page";
+  /** The mode the SDK was created in: the same `SdkMode` value the caller passed to `shareSdk` /
+   *  `createSdk` ("all-rentals-at-once": one call, no cursor, no limit). Default "default". */
+  readonly sdkMode?: SdkMode;
+  /** Random-sort seed, drawn once per page view by the caller. */
+  readonly seed: number;
+  /** Favourites removal delay (see `SearchState.leaving`). Default FAVORITE_LEAVE_MS; 0 = immediate
+   *  (the component passes 0 under prefers-reduced-motion). */
+  readonly leaveMs?: number;
+  /** The clock, for tests (and `sanitizeSearch`'s today). Default `() => new Date()`. */
+  readonly now?: () => Date;
+}
+/** The store's load state: loading until the first answer, ready, or error when nothing loaded. */
+type SearchStatus = "loading" | "ready" | "error";
+/** The page's narrowing by name, in the store's precedence (`SearchScope`): the favourites, the
+ *  offers, a fixed set, or the plain search. */
+type SearchScopeKind = "search" | "favorites" | "offers" | "ids";
+/** The snapshot every consumer reads. */
+interface SearchState {
+  /** "loading" until the first answer, "error" only when nothing loaded. */
+  readonly status: SearchStatus;
+  /** Every page in; false while a first-page reveal loads the rest, and after a later page failed
+   *  (what loaded stays: a partial set beats an error screen). */
+  readonly complete: boolean;
+  /** The current query (sanitised), without "?". */
+  readonly search: string;
+  /** What kind of search `search` is. */
+  readonly shape: QueryShape;
+  /** The page's narrowing (`options.scope`) by name; the count's suffix and the outcome's copy
+   *  follow it, so a satellite never restates it. */
+  readonly scope: SearchScopeKind;
+  /** After scopes, filters and the campaign, before the viewport: what the map plots. */
+  readonly matched: readonly SearchResultItem[];
+  /** After the viewport and the sort: what the list renders (leaving favourites included). */
+  readonly items: readonly SearchResultItem[];
+  /** The listed results (leaving favourites excluded); the count follows the map's viewport. */
+  readonly count: number;
+  /** Every result is an alternative on an exact search (the notice); waits for `complete`. */
+  readonly allAlternatives: boolean;
+  /** The ordering in the URL. */
+  readonly sort: SortKey;
+  /** Every `SortKey` with whether it can be chosen now. */
+  readonly sortOptions: readonly SortOptionState[];
+  /** The resolved filters the store was created with. */
+  readonly filters: ResolvedFilters | null;
+  /** The applied filters (chips), hidden ones included, led by the implicit `?property=` and
+   *  `?region=` scopes the curation has no facet for (`scope` set): every narrowing the URL applies
+   *  is visible and removable. */
+  readonly activeFilters: readonly ActiveFilter[];
+  /** Live counts over the listed set from the facts: a fact flag under its key, a facet value
+   *  under `key=value` (each counted without its own filter, so an OR option never reads 0
+   *  because a sibling is selected). */
+  readonly filterCounts: Readonly<Record<string, number>>;
+  /** Distinct PMS offer labels of the scoped results, first-seen, before `?campaign=` narrows
+   *  (the chips are built from them, so a selection can still switch). */
+  readonly offerLabels: readonly string[];
+  /** The campaign group in scope (the page's, else the URL's), or null. */
+  readonly campaign: string | null;
+  /** Null while results show or the walk has not settled. */
+  readonly outcome: SearchOutcome | null;
+  /** Keys the backend reported as having had no effect. */
+  readonly unusedFilterKeys: readonly string[];
+  /** The card the guest hovers or focuses (the map lights its pin). */
+  readonly highlighted: string | null;
+  /** The map's 220 ms re-settle pulse after a guest move (grid and count show skeletons). */
+  readonly reloading: boolean;
+  /** A viewport filter is active (the map drives the list). */
+  readonly viewportActive: boolean;
+  /** Favourites scope only: ids just un-hearted. They stay in `items` (the card renders
+   *  `data-state="leaving"` and animates out) for FAVORITE_LEAVE_MS, are already gone from
+   *  `matched` (the pin drops at once) and from `count`; then they leave `items`. Re-hearting
+   *  within the window cancels the removal. */
+  readonly leaving: ReadonlySet<string>;
+}
+/** The favourites-page removal animation window (the kits' 280 ms). */
+declare const FAVORITE_LEAVE_MS: 280;
+/** What every consumer may ask of the store. */
+interface SearchActions {
+  /** Change the query. A new live search runs only when the SDK-facing part changed (period,
+   *  occupancy, sdk filters, an id restriction, a server sort while incomplete); facts filters,
+   *  scopes, the campaign and a browser sort re-derive from the loaded set without a request. */
+  setSearch(search: string, mode?: "push" | "replace"): void;
+  /** Order in place ("replace" in the URL). */
+  setSort(key: SortKey): void;
+  /** The filter panel's selection (push). */
+  applyFilters(selection: FilterSelection): void;
+  /** Remove one chip (push). */
+  removeFilter(filter: ActiveFilter): void;
+  /** Remove every filter, hidden ones and the implicit scopes included (push). */
+  clearFilters(): void;
+  /** The ids inside the map bounds, or null for no viewport filter (results without coords
+   *  always stay: they cannot leave a view they are not in). */
+  setViewport(ids: ReadonlySet<string> | null): void;
+  /** The map's re-settle pulse (`reloading`). */
+  setReloading(on: boolean): void;
+  /** Drop the ?region= scope (push) so neighbouring results come back (map "release-on-move"). */
+  releaseRegionScope(): void;
+  /** Select a campaign group (replace), or null for every campaign in scope. */
+  setCampaign(group: string | null): void;
+  /** The card the guest hovers or focuses. */
+  setHighlighted(id: string | null): void;
+  /** Re-run the same search after an error. */
+  retry(): void;
+}
+/** The store: a snapshot, its subscription and the actions. */
+interface SearchStore extends Store<SearchState>, SearchActions {
+  /** Stop listening to the URL and the Merkliste, drop a running walk and pending removals. The
+   *  SDK stays (the caller owns it). */
+  dispose(): void;
+}
+/** The page's one live search. Never creates or disposes the SDK. */
+type CreateSearchStore = (source: SdkSource, options: SearchStoreOptions) => SearchStore;
+/** See {@link CreateSearchStore}. */
+declare const createSearchStore: CreateSearchStore;
+//#endregion
+//#region src/map/controller.d.ts
+/** The search store, structurally (`createSearchStore`'s store satisfies it). */
+type MapResultsSource = Pick<SearchStore, "getState" | "subscribe" | "setViewport" | "setReloading" | "releaseRegionScope">;
+/** Cluster settings for the GeoJSON source. */
+interface ClusterOptions {
+  /** px. Default 54. */
+  readonly radius?: number;
+  /** Clusters exist up to this zoom; points are individual from +1. Default 11. */
+  readonly maxZoom?: number;
+  /** Override for result sets whose pins carry prices (pills are ~70 px, dots 20: priced pills
+   *  stacked into one unreadable slab at the dot settings). */
+  readonly whenPriced?: {
+    readonly radius?: number;
+    readonly maxZoom?: number;
+  };
+}
+/** The kit's cluster settings (count-only bubbles). */
+declare const DEFAULT_CLUSTER: {
+  readonly radius: 54;
+  readonly maxZoom: 11;
+};
+/** The results map's behaviour switches. */
+interface ResultsMapOptions {
+  /** The list shows only results in the visible map area once the guest moved the map ("search
+   *  as you move"). Default true. */
+  readonly listFollowsMap?: boolean;
+  /** "release-on-move": the first guest move drops a ?region= scope so the neighbouring results
+   *  (already loaded) come back. Default "keep". */
+  readonly regionScope?: "keep" | "release-on-move";
+  /** Default "fan". */
+  readonly sameSpot?: SameSpotMode;
+  /** The first frame (padding, maxZoom, outliers). Default DEFAULT_FIT. */
+  readonly fit?: FitOptions;
+  /** The pins' price statement (the card's decision; a site may round pins only). */
+  readonly pins?: PinLabelOptions;
+}
+/** What a surface reports after every `moveend` and on every size change. */
+interface MapViewReport {
+  /** null when the surface has no size (CSS-hidden, a closed layer). */
+  readonly bounds: MapBounds | null;
+  /** The guest moved this surface (pointer, wheel, touch, key, a zoom button) since the previous
+   *  report. A programmatic fit is never the guest's. */
+  readonly byGuest: boolean;
+}
+/** Which surface reports: the map in the page, or its fullscreen layer. */
+type ResultsMapSurface = "inline" | "fullscreen";
+/** The controller's snapshot. */
+interface ResultsMapState {
+  /** "waiting": search not ready (no tiles are fetched); "empty": nothing to pin; "ready". */
+  readonly status: "waiting" | "empty" | "ready";
+  /** The pins of `matched`, in result order. */
+  readonly points: readonly MapPoint[];
+  /** Some pin carries a price (the cluster's `whenPriced` applies). */
+  readonly priced: boolean;
+  /** Recomputed once the component measured a pin (`setPinWidth`). */
+  readonly layout: SameSpotLayout;
+  /** Where a surface built now (or refitting) frames itself. */
+  readonly frame: MapBounds | null;
+  /** Increments when surfaces must refit to `frame`; never after a guest move. */
+  readonly frameVersion: number;
+  /** The rental whose popup is open. */
+  readonly openId: string | null;
+  /** The "group"-mode spot fanned out on a circle. */
+  readonly expandedGroup: string | null;
+  /** The guest moved a surface: refitting stops, the list may follow the map. */
+  readonly guestMoved: boolean;
+}
+/** The controller: its snapshot plus what surfaces and markers report. */
+interface ResultsMapController extends Store<ResultsMapState> {
+  /** A surface's bounds after a move or a resize (rules 1–4, 6). */
+  report(surface: ResultsMapSurface, view: MapViewReport): void;
+  /** The measured width of the widest pin body (re-lays the same-spot circles). */
+  setPinWidth(px: number): void;
+  /** Open a rental's popup. */
+  openPin(id: string): void;
+  /** Close the popup. */
+  closePopup(): void;
+  /** Toggle one group; null collapses (map click, zoom start). */
+  toggleGroup(key: string | null): void;
+  /** Detach; the list stops following (a map that is gone does not filter). */
+  dispose(): void;
+}
+/** The results map's behaviour as a store (rules 1–6 in the file header). */
+type CreateResultsMapController = (source: MapResultsSource, options?: ResultsMapOptions) => ResultsMapController;
+/** See {@link CreateResultsMapController}. */
+declare const createResultsMapController: CreateResultsMapController;
+//#endregion
+//#region src/map/places.d.ts
+/** A fixed place on a map. */
+interface MapPlace {
+  /** Shown in the popup and the marker label. */
+  readonly name: string;
+  /** Latitude. */
+  readonly lat: number;
+  /** Longitude. */
+  readonly lng: number;
+}
+/** One marker on a place map. */
+interface PlaceMarker {
+  /** The first place's coordinates. */
+  readonly at: LngLat;
+  /** Names of every place on this spot, in input order. */
+  readonly names: readonly string[];
+}
+/** Places within SAME_SPOT_METERS of a marker's first place join that marker. */
+type MergePlaces = (places: readonly MapPlace[]) => PlaceMarker[];
+/** See {@link MergePlaces}. */
+declare const mergePlaces: MergePlaces;
+//#endregion
+//#region src/map/address.d.ts
+/** "street": street, postcode and town. "town": the town only. It decides the printed line only;
+ *  the marker stays on the coordinates the PMS publishes (a coarsened marker would protect
+ *  nothing while the results map and the page data carry the same coordinates). */
+type RentalAddressMode = "street" | "town";
+/** The address line, or null when the feed states nothing. "street" without street data falls
+ *  back to the town (less than was decided, never more). Throws `RentalAddressModeError` for any
+ *  other mode value (an undecided page fails its build). */
+type RentalAddressLine = (rental: Pick<RentalDetail, "address" | "town">, mode: RentalAddressMode) => string | null;
+/** The address decision is missing or not one of the two modes (named, so a build log says
+ *  which decision is open). */
+declare class RentalAddressModeError extends Error {
+  constructor(mode: unknown);
+}
+/** See {@link RentalAddressLine}. */
+declare const rentalAddressLine: RentalAddressLine;
+//#endregion
+export { describeOutcome as $, RentalFlag as $i, fetchRentalFlags as $n, CardSource as $r, GuestBound as $t, QueryShape as A, SdkMode as Ai, LngLat as An, SdkConfigForInput as Ar, quickFilterDefs as At, toSdkQuery as B, RentalDistance as Bi, resultCardSource as Bn, RouteParams as Br, SEARCH_PARAMS as Bt, SearchState as C, isIsoDay as Ci, SameSpotGroup as Cn, EnvRecord as Cr, ResolvedFilters as Ct, createSearchStore as D, Locale as Di, circleOffsets as Dn, HUB_ENDPOINTS as Dr, facetOptions as Dt, SearchStoreOptions as E, Backend as Ei, SameSpotOptions as En, sdkConfigFromEnv as Er, activeFilters as Et, externalSearchHref as F, WebsiteSdk as Fi, mapPoints as Fn, CardSourceExtras as Fr, writeSelection as Ft, sortFromSearch as G, parseCounts as Gi, PreviewStrategy as Gn, CardBadge as Gr, SearchQuery as Gt, SORT_URL_VALUE as H, distanceFact as Hi, shortReviewerName as Hn, routeHref as Hr, SearchParamAliases as Ht, handoverQuery as I, resolveSdk as Ii, ResultLinkOptions as In, cardSource as Ir, partyPairs as It, EmptyCause as J, BedRun as Ji, DEFAULT_FLAG_FILTERS as Jn, CardImage as Jr, searchHref as Jt, sortResults as K, parseDistances as Ki, descriptionPreview as Kn, CardContext as Kr, WriteSearchOptions as Kt, queryShape as L, ADJACENT_BELOW_M as Li, SearchResultItem as Ln, loadRentalFacts as Lr, readParty as Lt, SanitizedSearch as M, SdkSetup as Mi, MapPoint as Mn, VofficeEndpointTable as Mr, resolveFilters as Mt, SdkQueryOptions as N, SdkSource as Ni, PinLabelOptions as Nn, VofficeEndpoints as Nr, withoutFilter as Nt, ExternalSearchLink as O, STAGES as Oi, distanceMeters as On, HubEndpointTable as Or, measureFilters as Ot, SdkSearchQuery as P, Stage as Pi, hasMapPoints as Pn, sdkConfigFor as Pr, withoutFilters as Pt, SearchedParts as Q, RentalDetail as Qi, assignSlugs as Qn, CardRating as Qr, DEFAULT_GUEST_LIMITS as Qt, resultsQueryFlagScript as R, DistanceKind as Ri, catalogueResultItem as Rn, rentalFactsMap as Rr, FlexibleStay as Rt, SearchScopeKind as S, formatIsoDate as Si, PixelOffset as Sn, createSdk as Sr, ResolveFiltersOptions as St, SearchStore as T, todayIso as Ti, SameSpotMode as Tn, SdkEnvError as Tr, WhenEmpty as Tt, SortKey as U, isAdjacent as Ui, splitReviewAuthor as Un, AlternativePeriod as Ur, SearchParamKeys as Ut, DEFAULT_SORT_OPTIONS as V, WATER_KINDS as Vi, newestReviewsFirst as Vn, RouteTemplate as Vr, SearchContract as Vt, SortOptionState as W, isSpecEcho as Wi, DescriptionPreview as Wn, BadgeRule as Wr, SearchPeriod as Wt, Relaxation as X, DescriptionContent as Xi, LoadRentalCatalogueOptions as Xn, CardModelOptions as Xr, ChildAgeRange as Xt, OutcomeInput as Y, CatalogueRental as Yi, FetchRentalFlagsOptions as Yn, CardLiveField as Yr, writeSearch as Yt, SearchOutcome as Z, RentalAddress as Zi, RentalFlagsResult as Zn, CardPill as Zr, DEFAULT_CHILD_AGE as Zt, FAVORITE_LEAVE_MS as _, EnhancePart as _a, Glyph as _i, DEFAULT_FIT as _n, fetchSearchPage as _r, FilterGroupSpec as _t, PlaceMarker as a, ReviewCriterion as aa, RentalFactsMap as ai, Party as an, AmenityPreviewItem as ar, OffersWindowSpec as at, SearchActions as b, GateMarkers as ba, IsoMonth as bi, frameFor as bn, SharedSdk as br, FilterSpec as bt, DEFAULT_CLUSTER as c, PlainTextOptions as ca, toCardModel as ci, clampParty as cn, AdaptEvent as cr, findCampaignStart as ct, ResultsMapController as d, StructuredDocumentOptions as da, Range as di, stayKeyOf as dn, adaptRental as dr, offersWindowQuery as dt, RentalImage as ea, CardStatus as ei, GuestBounds as en, loadRentalCatalogue as er, CampaignChip as et, ResultsMapOptions as f, TextMarkup as fa, matches as fi, Listener as fn, RawSearchPage as fr, ActiveFilter as ft, CampaignOf as g, ENHANCE_PARTS as ga, GLYPHS as gi, createStore as gn, WalkSummary as gr, FilterEntry as gt, createResultsMapController as h, plainText as ha, parsePriceLabel as hi, WritableStore as hn, WalkOptions as hr, FilterDef as ht, MapPlace as i, RentalRoom as ia, RentalFacts as ii, GuestOptions as in, ALWAYS_EXCLUDED_CATEGORIES as ir, OfferWindow as it, ResultHandoverOptions as j, SdkOptions as ji, MapBounds as jn, VOFFICE_ENDPOINTS as jr, readSelection as jt, ExternalSearchSource as k, SdkConfig as ki, layoutSameSpot as kn, HubEndpoints as kr, minimumSteps as kt, MapResultsSource as l, RichBlock as la, CardMatch as li, guestBounds as ln, AdaptRentalOptions as lr, findOfferWindows as lt, ResultsMapSurface as m, parseTextBlocks as ma, formatPriceLabel as mi, Unsubscribe as mn, SearchPageRequest as mr, FacetOptionsOptions as mt, RentalAddressModeError as n, RentalReview as na, PillOptions as ni, GuestKind as nn, slugify as nr, FindCampaignStartOptions as nt, mergePlaces as o, ReviewSummary as oa, StayPrice as oi, QuoteOccupancy as on, AmenityPreviewOptions as or, campaignChips as ot, ResultsMapState as p, normalizeStructuredDocument as pa, PriceCents as pi, Store as pn, SEARCH_PAGE_SIZE as pr, FacetOption as pt, toSdkSort as q, AmenityGroup as qi, descriptionSummary as qn, CardFact as qr, readSearch as qt, rentalAddressLine as r, RentalReviews as ra, RentalCardModel as ri, GuestLimits as rn, HIDDEN_ROOM_ATTRIBUTES as rr, FindOfferWindowsOptions as rt, ClusterOptions as s, RoomKind as sa, StayWindow as si, agesComplete as sn, amenityPreview as sr, campaignGroup as st, RentalAddressMode as t, RentalPropertyInfo as ta, FactKind as ti, GuestCaps as tn, rankHighlights as tr, CampaignChipsInput as tt, MapViewReport as u, RichInline as ua, CardSignal as ui, occupancyOf as un, RentalContentError as ur, offerWindowHref as ut, FavoritesPort as v, EnhanceParts as va, GlyphList as vi, DefaultFit as vn, walkSearchPages as vr, FilterMeasurement as vt, SearchStatus as w, nightsBetween as wi, SameSpotLayout as wn, SDK_ENV as wr, SdkFilterDefinition as wt, SearchScope as x, addDays as xi, idsInView as xn, shareSdk as xr, ImplicitScope as xt, HistoryPort as y, GATE_MARKERS as ya, IsoDay as yi, FitOptions as yn, loadSharedSdk as yr, FilterSelection as yt, sanitizeSearch as z, RentalCounts as zi, compareUndatedSearchOrder as zn, withRentalFacts as zr, QueryPair as zt };