@riverbankcms/sdk 0.85.0 → 0.89.1

package/dist/_dts/blocks/src/system/runtime/nodes/newsletter-form.client.state.d.ts

@@ -6,7 +6,29 @@ export type NewsletterFormError = Readonly<{
     kind: 'form';
     message: string;
 }>;
+export type NewsletterFormSubmissionState = Readonly<{
+    tag: 'idle';
+}> | Readonly<{
+    tag: 'submitting';
+}> | Readonly<{
+    tag: 'error';
+    error: NewsletterFormError;
+}> | Readonly<{
+    tag: 'success';
+}>;
+export type NewsletterFormSubmissionAction = Readonly<{
+    type: 'submitted';
+}> | Readonly<{
+    type: 'failed';
+    error: NewsletterFormError;
+}> | Readonly<{
+    type: 'succeeded';
+}>;
+export declare const initialNewsletterFormSubmissionState: NewsletterFormSubmissionState;
+export declare function newsletterFormSubmissionReducer(state: NewsletterFormSubmissionState, action: NewsletterFormSubmissionAction): NewsletterFormSubmissionState;
 export declare function newsletterFieldError(fieldId: string, message: string): NewsletterFormError;
 export declare function newsletterFormError(message: string): NewsletterFormError;
-export declare function getNewsletterFieldError(error: NewsletterFormError | null, fieldId: string): string | null;
-export declare function getNewsletterFormError(error: NewsletterFormError | null): string | null;
+export declare function isNewsletterFormSubmitting(state: NewsletterFormSubmissionState): boolean;
+export declare function isNewsletterFormSuccess(state: NewsletterFormSubmissionState): boolean;
+export declare function getNewsletterSubmissionFieldError(state: NewsletterFormSubmissionState, fieldId: string): string | null;
+export declare function getNewsletterSubmissionFormError(state: NewsletterFormSubmissionState): string | null;

package/dist/_dts/blocks/src/system/runtime/nodes/newsletter-form.interactive.d.ts

@@ -1,9 +1,12 @@
 import { type InteractiveIslandProps } from '../../../contracts/islands';
+import { type NewsletterSignupDestinationProvider, type NewsletterSignupPublicDestinationRef } from '../../blocks/newsletter-signup-destination';
 import { type NewsletterFieldDef, type NewsletterPreset } from './newsletter-form.types';
 export type NewsletterFormSourceProps = Readonly<{
+    blockId?: string | null;
     siteId?: string;
     apiBaseUrl?: string;
     listId?: string | null;
+    destinationProvider?: NewsletterSignupDestinationProvider | null;
     preset?: NewsletterPreset;
     includePhone?: boolean;
     buttonLabel?: string | null;
@@ -22,6 +25,7 @@ export type NewsletterFormDisplay = Readonly<{
     fields: readonly NewsletterFieldDef[];
 }>;
 export type NewsletterFormHydration = Readonly<{
+    destinationRef?: NewsletterSignupPublicDestinationRef | null;
     listId?: string | null;
     preset: NewsletterPreset;
     includePhone: boolean;
@@ -37,9 +41,11 @@ export type NewsletterFormInteractiveIslandProps = InteractiveIslandProps<Newsle
 export declare const newsletterFormBlockRuntime: Readonly<{
     kind: "progressive";
     buildRender: (source: Readonly<{
+        blockId?: string | null;
         siteId?: string;
         apiBaseUrl?: string;
         listId?: string | null;
+        destinationProvider?: NewsletterSignupDestinationProvider | null;
         preset?: NewsletterPreset;
         includePhone?: boolean;
         buttonLabel?: string | null;
@@ -58,6 +64,7 @@ export declare const newsletterFormBlockRuntime: Readonly<{
             fields: readonly NewsletterFieldDef[];
         }>;
         hydration: Readonly<{
+            destinationRef?: NewsletterSignupPublicDestinationRef | null;
             listId?: string | null;
             preset: NewsletterPreset;
             includePhone: boolean;
@@ -68,9 +75,11 @@ export declare const newsletterFormBlockRuntime: Readonly<{
     contracts: Readonly<{
         source: Readonly<{
             encode: (value: Readonly<{
+                blockId?: string | null;
                 siteId?: string;
                 apiBaseUrl?: string;
                 listId?: string | null;
+                destinationProvider?: NewsletterSignupDestinationProvider | null;
                 preset?: NewsletterPreset;
                 includePhone?: boolean;
                 buttonLabel?: string | null;
@@ -81,9 +90,11 @@ export declare const newsletterFormBlockRuntime: Readonly<{
                 className?: string | null;
             }>) => unknown;
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
+                blockId?: string | null;
                 siteId?: string;
                 apiBaseUrl?: string;
                 listId?: string | null;
+                destinationProvider?: NewsletterSignupDestinationProvider | null;
                 preset?: NewsletterPreset;
                 includePhone?: boolean;
                 buttonLabel?: string | null;
@@ -105,6 +116,7 @@ export declare const newsletterFormBlockRuntime: Readonly<{
                     fields: readonly NewsletterFieldDef[];
                 }>;
                 hydration: Readonly<{
+                    destinationRef?: NewsletterSignupPublicDestinationRef | null;
                     listId?: string | null;
                     preset: NewsletterPreset;
                     includePhone: boolean;
@@ -122,6 +134,7 @@ export declare const newsletterFormBlockRuntime: Readonly<{
                     fields: readonly NewsletterFieldDef[];
                 }>;
                 hydration: Readonly<{
+                    destinationRef?: NewsletterSignupPublicDestinationRef | null;
                     listId?: string | null;
                     preset: NewsletterPreset;
                     includePhone: boolean;
@@ -150,6 +163,7 @@ export declare const newsletterFormInteractiveIslandPropsCodec: Readonly<{
                 fields: readonly NewsletterFieldDef[];
             }>;
             hydration: Readonly<{
+                destinationRef?: NewsletterSignupPublicDestinationRef | null;
                 listId?: string | null;
                 preset: NewsletterPreset;
                 includePhone: boolean;
@@ -175,6 +189,7 @@ export declare const newsletterFormInteractiveIslandPropsCodec: Readonly<{
                 fields: readonly NewsletterFieldDef[];
             }>;
             hydration: Readonly<{
+                destinationRef?: NewsletterSignupPublicDestinationRef | null;
                 listId?: string | null;
                 preset: NewsletterPreset;
                 includePhone: boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/newsletter-form.server.d.ts

@@ -6,5 +6,5 @@ import type { NewsletterFormProps } from './newsletter-form.types';
  * Renders the newsletter signup form for SSR with hydration support.
  * Uses the islands architecture pattern to hydrate on the client.
  */
-export declare function NewsletterFormSSR({ blockId, siteId, apiBaseUrl, listId, preset, includePhone, buttonLabel, successMessage, privacyNote, tags, spamProtectionEnabled, className, }: NewsletterFormProps): React.JSX.Element;
+export declare function NewsletterFormSSR({ blockId, siteId, apiBaseUrl, listId, destinationProvider, preset, includePhone, buttonLabel, successMessage, privacyNote, tags, spamProtectionEnabled, className, }: NewsletterFormProps): React.JSX.Element;
 export default NewsletterFormSSR;

package/dist/_dts/blocks/src/system/runtime/nodes/newsletter-form.submission.d.ts

@@ -0,0 +1,32 @@
+import type { NewsletterSubscribeTarget } from '../api/types';
+import type { NewsletterSignupPublicDestinationRef } from '../../blocks/newsletter-signup-destination';
+export type NewsletterFormRawSubmissionFields = Readonly<{
+    email: FormDataEntryValue | null;
+    firstName: FormDataEntryValue | null;
+    lastName: FormDataEntryValue | null;
+    name: FormDataEntryValue | null;
+    company: FormDataEntryValue | null;
+    phone: FormDataEntryValue | null;
+    website: FormDataEntryValue | null;
+}>;
+export type NewsletterFormSubmissionFields = Readonly<{
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    company?: string;
+    phone?: string;
+    honeypot: string;
+}>;
+export type NewsletterSubmitTargetResolution = Readonly<{
+    tag: 'ready';
+    target: NewsletterSubscribeTarget;
+}> | Readonly<{
+    tag: 'unavailable';
+    reason: 'missing_legacy_list';
+}>;
+export declare function mapNewsletterFormFieldsToSubscriberInput(fields: NewsletterFormRawSubmissionFields): NewsletterFormSubmissionFields;
+export declare function resolveNewsletterSubmitTarget(input: Readonly<{
+    listId?: string | null;
+    destinationRef?: NewsletterSignupPublicDestinationRef | null;
+}>): NewsletterSubmitTargetResolution;

package/dist/_dts/blocks/src/system/runtime/nodes/newsletter-form.types.d.ts

@@ -3,7 +3,8 @@
  *
  * Shared types for the newsletter form server and client components.
  */
-export type NewsletterPreset = 'emailOnly' | 'emailName' | 'emailFirstLast' | 'emailNameCompany';
+import type { NewsletterSignupFieldPreset } from '../../blocks/newsletter-signup-destination';
+export type NewsletterPreset = NewsletterSignupFieldPreset;
 export type NewsletterFieldDef = {
     id: string;
     type: 'email' | 'text';
@@ -11,6 +12,7 @@ export type NewsletterFieldDef = {
     required: boolean;
     placeholder?: string;
 };
+export type NewsletterDestinationProvider = 'riverbank' | 'mailchimp';
 export type NewsletterFormProps = {
     /** Block ID for island hydration */
     blockId?: string | null;
@@ -20,6 +22,8 @@ export type NewsletterFormProps = {
     apiBaseUrl?: string;
     /** Newsletter list ID to subscribe users to */
     listId?: string | null;
+    /** Active signup destination provider */
+    destinationProvider?: NewsletterDestinationProvider | null;
     /** Field preset configuration */
     preset?: NewsletterPreset;
     /** Adds an optional phone field to the selected preset */

package/dist/_dts/blocks/src/system/runtime/nodes/shared/MagicLinkForm.state.d.ts

@@ -0,0 +1,24 @@
+export type MagicLinkSubmissionState = Readonly<{
+    tag: 'idle';
+}> | Readonly<{
+    tag: 'submitting';
+}> | Readonly<{
+    tag: 'success';
+}> | Readonly<{
+    tag: 'error';
+    message: string;
+}>;
+export type MagicLinkSubmissionAction = Readonly<{
+    type: 'submit-started';
+}> | Readonly<{
+    type: 'submit-succeeded';
+}> | Readonly<{
+    type: 'submit-failed';
+    message: string;
+}> | Readonly<{
+    type: 'reset';
+}>;
+export declare const initialMagicLinkSubmissionState: MagicLinkSubmissionState;
+export declare function magicLinkSubmissionReducer(state: MagicLinkSubmissionState, action: MagicLinkSubmissionAction): MagicLinkSubmissionState;
+export declare function isMagicLinkSubmitting(state: MagicLinkSubmissionState): boolean;
+export declare function getMagicLinkError(state: MagicLinkSubmissionState): string | null;

package/dist/_dts/blocks/src/system/runtime/shared/components/ModalShell.d.ts

@@ -1,4 +1,5 @@
 import * as React from 'react';
+type ModalShellPortalWrapperProps = Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'className'> & Partial<Record<`data-${string}`, string>>;
 export type ModalShellProps = Readonly<{
     title: string;
     titleId: string;
@@ -6,6 +7,8 @@ export type ModalShellProps = Readonly<{
     children: React.ReactNode;
     portalRoot?: HTMLElement | null;
     portal?: boolean;
+    portalWrapperClassName?: string;
+    portalWrapperProps?: ModalShellPortalWrapperProps;
     overlayClassName: string;
     modalClassName: string;
     renderSrOnlyTitle?: boolean;
@@ -27,4 +30,5 @@ export type ModalShellProps = Readonly<{
  * focus, escape handling, body-scroll locking, overlay clicks, and optional
  * portaling into a themed root.
  */
-export declare function ModalShell({ title, titleId, onClose, children, portalRoot, portal, overlayClassName, modalClassName, renderSrOnlyTitle, renderHeader, headerClassName, titleClassName, closeButtonClassName, closeIcon, }: ModalShellProps): React.ReactNode;
+export declare function ModalShell({ title, titleId, onClose, children, portalRoot, portal, portalWrapperClassName, portalWrapperProps, overlayClassName, modalClassName, renderSrOnlyTitle, renderHeader, headerClassName, titleClassName, closeButtonClassName, closeIcon, }: ModalShellProps): React.ReactNode;
+export {};

package/dist/_dts/blocks/src/system/runtime/shared/useWaitlistClaim.state.d.ts

@@ -0,0 +1,35 @@
+import type { ResolveWaitlistClaimResponse } from "../api/types";
+export type WaitlistClaimResolveFailure = Readonly<{
+    kind: "portal-login-required";
+    message: string;
+}> | Readonly<{
+    kind: "error";
+    message: string;
+}>;
+export type WaitlistClaimState = Readonly<{
+    kind: "idle";
+}> | Readonly<{
+    kind: "resolving";
+}> | Readonly<{
+    kind: "resolved";
+    claim: ResolveWaitlistClaimResponse;
+}> | WaitlistClaimResolveFailure;
+export type WaitlistClaimAction = Readonly<{
+    type: "cleared";
+}> | Readonly<{
+    type: "started";
+}> | Readonly<{
+    type: "resolved";
+    claim: ResolveWaitlistClaimResponse;
+}> | Readonly<{
+    type: "failed";
+    failure: WaitlistClaimResolveFailure;
+}>;
+export declare function createInitialWaitlistClaimState(hasToken: boolean): WaitlistClaimState;
+export declare function waitlistClaimReducer(_state: WaitlistClaimState, action: WaitlistClaimAction): WaitlistClaimState;
+export declare function toWaitlistClaimResolveFailure(error: unknown): WaitlistClaimResolveFailure;
+export declare function getWaitlistClaim(state: WaitlistClaimState): ResolveWaitlistClaimResponse | null;
+export declare function getWaitlistClaimError(state: WaitlistClaimState): string | null;
+export declare function getWaitlistClaimLoginMessage(state: WaitlistClaimState): string | null;
+export declare function requiresWaitlistClaimPortalLogin(state: WaitlistClaimState): boolean;
+export declare function isWaitlistClaimLoading(state: WaitlistClaimState): boolean;

package/dist/_dts/blocks/src/system/runtime/shared/utils/formatting.d.ts

@@ -8,7 +8,7 @@
  *
  * @param cents - Price in cents
  * @param currency - ISO 4217 currency code (e.g., 'USD', 'GBP')
- * @param locale - Optional locale for formatting (defaults to browser locale)
+ * @param locale - Optional locale override (defaults to the currency's locale)
  * @returns Formatted price string (e.g., "£100.00")
  */
 export declare function formatPrice(cents: number, currency?: string, locale?: string): string;

package/dist/_dts/content-model/src/entry-slots/types.d.ts

@@ -320,6 +320,60 @@ export type SdkEntryBlocksPatchParseError = Readonly<{
     blockKind: string;
 }>;
 export declare function parseSdkEntryBlocksPatch(blocks: unknown): EntrySlotResult<SdkEntryBlocksPatch, SdkEntryBlocksPatchParseError>;
+export type SlotContainerOwner = Readonly<{
+    kind: 'contentEntry';
+    contentEntryId: EntrySlotContentEntryId;
+}>;
+export type SlotContainerOwnerParseError = Readonly<{
+    kind: 'not-object';
+}> | Readonly<{
+    kind: 'unsupported-owner-kind';
+    ownerKind: unknown;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: NonEmptyStringParseError;
+}>;
+export declare function parseSlotContainerOwner(input: unknown): EntrySlotResult<SlotContainerOwner, SlotContainerOwnerParseError>;
+export declare function slotContainerOwnerToContentVersionOwner(owner: SlotContainerOwner): ContentVersionOwner;
+export declare function slotContainerOwnerToEntrySlotLookup(owner: SlotContainerOwner): Readonly<{
+    contentEntryId: EntrySlotContentEntryId;
+}>;
+export type PlannedSlotCompositionBlockWrite = Readonly<{
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    content: Record<string, unknown>;
+    orderIndex: EntrySlotBlockOrderIndex;
+}>;
+export type SlotCompositionMutationInput = Readonly<{
+    kind: 'leaveUnchanged';
+}> | Readonly<{
+    kind: 'replaceDraftComposition';
+    blocks: readonly PlannedSlotCompositionBlockWrite[];
+}> | Readonly<{
+    kind: 'publishDraftComposition';
+    draftVersionId: EntrySlotContentVersionId;
+}>;
+export type SlotCompositionMutationPlan = Readonly<{
+    kind: 'noChange';
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'replaceDraftComposition';
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+    blocks: readonly PlannedSlotCompositionBlockWrite[];
+}> | Readonly<{
+    kind: 'publishDraftComposition';
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+    draftVersionId: EntrySlotContentVersionId;
+}>;
+export declare function planSlotCompositionMutation(input: Readonly<{
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+    mutation: SlotCompositionMutationInput;
+}>): SlotCompositionMutationPlan;
 export type ContentVersionOwner = Readonly<{
     kind: 'block';
     blockId: EntrySlotBlockId;

package/dist/_dts/content-model/src/referenceFields.d.ts

@@ -1,4 +1,4 @@
-export declare const BUILT_IN_REFERENCE_KINDS: readonly ["post", "form", "bookingForm", "appointmentService", "appointmentResource", "page", "newsletterList"];
+export declare const BUILT_IN_REFERENCE_KINDS: readonly ["post", "form", "bookingForm", "appointmentService", "appointmentResource", "page", "newsletterList", "mailchimpAudience"];
 export type BuiltInReferenceKind = (typeof BUILT_IN_REFERENCE_KINDS)[number];
 export type EntryPickerValueFrom = 'id' | 'identifier' | 'slug';
 declare const referenceContentTypeKeyBrand: unique symbol;

package/dist/_dts/core/src/branded.d.ts

@@ -24,7 +24,9 @@ export type BrandedIdParseError = {
 export declare function expectParsedBrandedId<TBrand>(result: Result<TBrand, BrandedIdParseError>): TBrand;
 export type EventInstanceId = Brand<string, 'EventInstanceId'>;
 export type SiteId = Brand<string, 'SiteId'>;
+export type SiteRouteId = Brand<string, 'SiteRouteId'>;
 export type PageId = Brand<string, 'PageId'>;
+export type PageSurfaceId = Brand<string, 'PageSurfaceId'>;
 export type OccurrenceId = Brand<string, 'OccurrenceId'>;
 export type EventSeriesId = Brand<string, 'EventSeriesId'>;
 export type TicketTypeId = Brand<string, 'TicketTypeId'>;
@@ -137,7 +139,9 @@ export declare const unsafeAsEntryId: (id: string) => EntryId;
 export declare const unsafeAsPreviewEntryId: (id: string) => PreviewEntryId;
 export declare const unsafeAsEventInstanceId: (id: string) => EventInstanceId;
 export declare const unsafeAsSiteId: (id: string) => SiteId;
+export declare const unsafeAsSiteRouteId: (id: string) => SiteRouteId;
 export declare const unsafeAsPageId: (id: string) => PageId;
+export declare const unsafeAsPageSurfaceId: (id: string) => PageSurfaceId;
 export declare const unsafeAsOccurrenceId: (id: string) => OccurrenceId;
 export declare const unsafeAsEventSeriesId: (id: string) => EventSeriesId;
 export declare const unsafeAsTicketTypeId: (id: string) => TicketTypeId;
@@ -224,6 +228,9 @@ export declare const unsafeAsEncounterRecordId: (id: string) => EncounterRecordI
 export declare const unsafeAsRecordEntryId: (id: string) => RecordEntryId;
 export declare const unsafeAsProtectedPayloadKeyVersion: (id: string) => ProtectedPayloadKeyVersion;
 export declare const parseSiteId: (value: unknown) => Result<SiteId, BrandedIdParseError>;
+export declare const parseSiteRouteId: (value: unknown) => Result<SiteRouteId, BrandedIdParseError>;
+export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdParseError>;
+export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;
 export declare const parseOccurrenceId: (value: unknown) => Result<OccurrenceId, BrandedIdParseError>;
 export declare const parseTicketTypeId: (value: unknown) => Result<TicketTypeId, BrandedIdParseError>;
 export declare const parsePricingOptionId: (value: unknown) => Result<PricingOptionId, BrandedIdParseError>;

package/dist/_dts/core/src/currency-format.d.ts

@@ -1,4 +1,39 @@
+declare const currencyCodeBrand: unique symbol;
 /**
- * Format minor currency units using the locale customers expect for that code.
+ * A validated currency code (three ASCII letters), normalized to upper-case.
+ * Branding stops arbitrary strings flowing into money formatting at boundaries.
  */
-export declare function formatCurrencyAmount(amountCents: number, currency: string): string;
+export type CurrencyCode = string & {
+    readonly [currencyCodeBrand]: true;
+};
+export declare function isCurrencyCode(value: unknown): value is CurrencyCode;
+/** Parse + normalize a currency code, or return null if it isn't a 3-letter code. */
+export declare function parseCurrencyCode(value: string): CurrencyCode | null;
+/**
+ * Brand an already-trusted currency code (DB column, generated constant, fixture).
+ * Use `parseCurrencyCode` for untrusted boundary values.
+ */
+export declare function unsafeCurrencyCode(value: string): CurrencyCode;
+/**
+ * Trailing-decimal policy for a formatted amount:
+ * - 'exact' : the currency's natural precision (usually 2) — "£25.00"
+ * - 'auto'  : drop trailing zeros within the currency's natural precision — "£25", "£25.50"
+ */
+export type CurrencyDecimals = 'exact' | 'auto';
+export type FormatCurrencyOptions = Readonly<{
+    /** Defaults to 'exact'. */
+    decimals?: CurrencyDecimals;
+    /** Override the locale; defaults to the locale customers expect for the currency. */
+    locale?: string;
+}>;
+/**
+ * The single currency-amount formatter for the product: minor units in,
+ * localized string out.
+ *
+ * The locale is derived from the currency by default, so output is deterministic
+ * across server and client (no SSR/hydration mismatch). All other money
+ * formatters in the codebase should delegate here rather than constructing their
+ * own `Intl.NumberFormat`.
+ */
+export declare function formatCurrencyAmount(amountCents: number, currency: string, options?: FormatCurrencyOptions): string;
+export {};

package/dist/_dts/core/src/event-pricing.d.ts

@@ -1,3 +1,4 @@
+import { type CurrencyDecimals } from "./currency-format";
 export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types"];
 export type EventPricingMode = (typeof EVENT_PRICING_MODES)[number];
 export type PublicEventPricingType = "free" | "paid";
@@ -29,9 +30,15 @@ export type PublicEventTicketTypePriceDisplay = PublicEventFreePriceDisplay | Pu
     kind: "from";
     amount: number;
     currency: string;
+}> | Readonly<{
+    kind: "range";
+    minAmount: number;
+    maxAmount: number;
+    currency: string;
 }> | Readonly<{
     kind: "mixed";
     paidFromAmount: number;
+    paidToAmount: number;
     currency: string;
 }> | Readonly<{
     kind: "unavailable";
@@ -73,3 +80,20 @@ export declare function publicEventPricingCurrency(pricing: PublicEventPricing<u
 export declare function publicEventScalarPrice(pricing: PublicEventPricing<unknown>): number | null;
 export declare function publicEventPricingMode(pricing: PublicEventPricing<unknown>): EventPricingMode | undefined;
 export declare function publicEventTicketTypes<TTicketType>(pricing: PublicEventPricing<TTicketType>): readonly TTicketType[];
+export type BookingPriceDisplay = PublicEventPriceDisplay;
+export type FormatBookingPriceDisplayOptions = Readonly<{
+    /** Trailing-decimal policy passed through to the currency formatter. */
+    decimals?: CurrencyDecimals;
+    /** Locale override; defaults to the currency's expected locale. */
+    locale?: string;
+}>;
+/**
+ * The single renderer for a precomputed booking price `display` ADT. This is
+ * the one place booking price variants map to user-facing strings — every call
+ * site (booking entry, events calendar, event/course details, listings, portal)
+ * should route through here so labels never drift. Adding a variant to the ADT
+ * breaks compilation here (via `assertNever`) until it is handled.
+ */
+export declare function formatBookingPriceDisplay(display: BookingPriceDisplay, options?: FormatBookingPriceDisplayOptions): string;
+/** Render an event's price directly from its pricing value. */
+export declare function formatEventPricing(pricing: PublicEventPricing<unknown>, options?: FormatBookingPriceDisplayOptions): string;

package/dist/_dts/core/src/index.d.ts

@@ -42,5 +42,6 @@ export * from "./slug";
 export * from "./string";
 export * from "./uuid";
 export * from "./stable-json";
+export * from "./site-route-target";
 export { disabledSelection, enabledSelection, plannerNoChange, plannerPatch, plannerUpdate, resolvePlanningDateInput, resolvePlanningNow, resolvePlanningNowDate, systemPlanningClock, } from "./planner";
 export type { DisabledSelection, EnabledSelection, OptionalSelection, PlannerNoChange, PlannerPatch, PlannerUpdate, PlanningClock, PlanningDateInput, PlanningTimeOptions, } from "./planner";

package/dist/_dts/core/src/site-route-target.d.ts

@@ -0,0 +1,40 @@
+import { type BrandedIdParseError, type ContentEntryId, type PageId, type PageSurfaceId } from './branded';
+import { type Result } from './result';
+export declare const SITE_ROUTE_NODE_TYPES: readonly ["page", "content_entry", "page_surface"];
+export type SiteRouteNodeType = (typeof SITE_ROUTE_NODE_TYPES)[number];
+export type SiteRouteTarget = Readonly<{
+    kind: 'page';
+    pageId: PageId;
+}> | Readonly<{
+    kind: 'contentEntry';
+    entryId: ContentEntryId;
+}> | Readonly<{
+    kind: 'pageSurface';
+    surfaceId: PageSurfaceId;
+}>;
+export type SiteRouteTargetParseError = Readonly<{
+    kind: 'invalid-node-type';
+    nodeType: unknown;
+}> | Readonly<{
+    kind: 'unsupported-node-type';
+    nodeType: string;
+}> | Readonly<{
+    kind: 'invalid-page-id';
+    error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalid-page-surface-id';
+    error: BrandedIdParseError;
+}>;
+export declare function parseSiteRouteTarget(input: Readonly<{
+    nodeType: unknown;
+    nodeId: unknown;
+}>): Result<SiteRouteTarget, SiteRouteTargetParseError>;
+export declare function siteRouteTargetNodeType(target: SiteRouteTarget): SiteRouteNodeType;
+export declare function foldSiteRouteTarget<TValue>(target: SiteRouteTarget, cases: Readonly<{
+    page: (pageId: PageId) => TValue;
+    contentEntry: (entryId: ContentEntryId) => TValue;
+    pageSurface: (surfaceId: PageSurfaceId) => TValue;
+}>): TValue;