@riverbankcms/sdk 0.136.0 → 0.138.0

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

@@ -33,7 +33,7 @@ export type OccurrenceId = Brand<string, 'OccurrenceId'>;
 export type EventOfferingId = Brand<string, 'EventOfferingId'>;
 export type EventSeriesId = Brand<string, 'EventSeriesId'>;
 export type EventPageRouteSlug = Brand<string, 'EventPageRouteSlug'>;
-export type TicketTypeId = Brand<string, 'TicketTypeId'>;
+export type EventAttendeeTicketLineId = Brand<string, 'EventAttendeeTicketLineId'>;
 export type EventSeriesRegistrationId = Brand<string, 'EventSeriesRegistrationId'>;
 export type EventCategoryId = Brand<string, 'EventCategoryId'>;
 export type VenueId = Brand<string, 'VenueId'>;
@@ -71,8 +71,12 @@ export type FormId = Brand<string, 'FormId'>;
 export type FormSubmissionId = Brand<string, 'FormSubmissionId'>;
 export type PassId = Brand<string, 'PassId'>;
 export type MembershipId = Brand<string, 'MembershipId'>;
-export type CourseId = Brand<string, 'CourseId'>;
-export type CourseProgramId = Brand<string, 'CourseProgramId'>;
+/**
+ * Historical identity carried by pre-cutover order-item metadata under the
+ * `courseId` wire key. There is no live Course entity: this brand exists only
+ * so historical snapshots decode to something typed. Parse-only by design.
+ */
+export type RetiredCourseId = Brand<string, 'RetiredCourseId'>;
 export type CustomerId = Brand<string, 'CustomerId'>;
 export type OrderId = Brand<string, 'OrderId'>;
 export type OrderItemId = Brand<string, 'OrderItemId'>;
@@ -84,6 +88,18 @@ export type OrderPaymentPlanInstalmentId = Brand<string, 'OrderPaymentPlanInstal
 export type ManualPaymentOperationId = Brand<string, 'ManualPaymentOperationId'>;
 export type CheckoutLineId = Brand<string, 'CheckoutLineId'>;
 export type AttendeeId = Brand<string, 'AttendeeId'>;
+/** Client-generated identity for one registration submission (#1273). */
+export type EventRegistrationCommandId = Brand<string, 'EventRegistrationCommandId'>;
+/**
+ * The command *row* that records one registration submission.
+ *
+ * Distinct from `EventRegistrationCommandId`, which is the client's own id for
+ * the submission. Both are UUIDs and both travel together through the order
+ * projection, so the type is what stops one being handed over where the other
+ * is meant.
+ */
+export type EventRegistrationCommandRowId = Brand<string, 'EventRegistrationCommandRowId'>;
+export type EventRegistrationProjectionClaimToken = Brand<string, 'EventRegistrationProjectionClaimToken'>;
 export type CustomerPassId = Brand<string, 'CustomerPassId'>;
 export type CustomerMembershipId = Brand<string, 'CustomerMembershipId'>;
 export type AppointmentId = Brand<string, 'AppointmentId'>;
@@ -169,7 +185,7 @@ export declare const unsafeAsOccurrenceId: (id: string) => OccurrenceId;
 export declare const unsafeAsEventOfferingId: (id: string) => EventOfferingId;
 export declare const unsafeAsEventSeriesId: (id: string) => EventSeriesId;
 export declare const unsafeAsEventPageRouteSlug: (value: string) => EventPageRouteSlug;
-export declare const unsafeAsTicketTypeId: (id: string) => TicketTypeId;
+export declare const unsafeAsEventAttendeeTicketLineId: (id: string) => EventAttendeeTicketLineId;
 export declare const unsafeAsEventSeriesRegistrationId: (id: string) => EventSeriesRegistrationId;
 export declare const unsafeAsEventCategoryId: (id: string) => EventCategoryId;
 export declare const unsafeAsVenueId: (id: string) => VenueId;
@@ -207,8 +223,6 @@ export declare const unsafeAsFormId: (id: string) => FormId;
 export declare const unsafeAsFormSubmissionId: (id: string) => FormSubmissionId;
 export declare const unsafeAsPassId: (id: string) => PassId;
 export declare const unsafeAsMembershipId: (id: string) => MembershipId;
-export declare const unsafeAsCourseId: (id: string) => CourseId;
-export declare const unsafeAsCourseProgramId: (id: string) => CourseProgramId;
 export declare const unsafeAsCustomerId: (id: string) => CustomerId;
 export declare const unsafeAsOrderId: (id: string) => OrderId;
 export declare const unsafeAsOrderItemId: (id: string) => OrderItemId;
@@ -220,6 +234,9 @@ export declare const unsafeAsOrderPaymentPlanInstalmentId: (id: string) => Order
 export declare const unsafeAsManualPaymentOperationId: (id: string) => ManualPaymentOperationId;
 export declare const unsafeAsCheckoutLineId: (id: string) => CheckoutLineId;
 export declare const unsafeAsAttendeeId: (id: string) => AttendeeId;
+export declare const unsafeAsEventRegistrationCommandId: (id: string) => EventRegistrationCommandId;
+export declare const unsafeAsEventRegistrationCommandRowId: (id: string) => EventRegistrationCommandRowId;
+export declare const unsafeAsEventRegistrationProjectionClaimToken: (id: string) => EventRegistrationProjectionClaimToken;
 export declare const unsafeAsCustomerPassId: (id: string) => CustomerPassId;
 export declare const unsafeAsCustomerMembershipId: (id: string) => CustomerMembershipId;
 export declare const unsafeAsAppointmentId: (id: string) => AppointmentId;
@@ -277,8 +294,7 @@ export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdPa
 export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;
 export declare const parseOccurrenceId: (value: unknown) => Result<OccurrenceId, BrandedIdParseError>;
 export declare const parseEventOfferingId: (value: unknown) => Result<EventOfferingId, BrandedIdParseError>;
-export declare const parseCourseProgramId: (value: unknown) => Result<CourseProgramId, BrandedIdParseError>;
-export declare const parseTicketTypeId: (value: unknown) => Result<TicketTypeId, BrandedIdParseError>;
+export declare const parseEventAttendeeTicketLineId: (value: unknown) => Result<EventAttendeeTicketLineId, BrandedIdParseError>;
 export declare const parsePricingOptionId: (value: unknown) => Result<PricingOptionId, BrandedIdParseError>;
 export declare const parseUserId: (value: unknown) => Result<UserId, BrandedIdParseError>;
 export declare const parseProductId: (value: unknown) => Result<ProductId, BrandedIdParseError>;
@@ -292,7 +308,7 @@ export declare const parseNavigationMenuId: (value: unknown) => Result<Navigatio
 export declare const parseNavigationItemId: (value: unknown) => Result<NavigationItemId, BrandedIdParseError>;
 export declare const parsePassId: (value: unknown) => Result<PassId, BrandedIdParseError>;
 export declare const parseMembershipId: (value: unknown) => Result<MembershipId, BrandedIdParseError>;
-export declare const parseCourseId: (value: unknown) => Result<CourseId, BrandedIdParseError>;
+export declare const parseRetiredCourseId: (value: unknown) => Result<RetiredCourseId, BrandedIdParseError>;
 export declare const parseFormId: (value: unknown) => Result<FormId, BrandedIdParseError>;
 export declare const parseAppointmentId: (value: unknown) => Result<AppointmentId, BrandedIdParseError>;
 export declare const parseAppointmentServiceId: (value: unknown) => Result<AppointmentServiceId, BrandedIdParseError>;
@@ -300,6 +316,9 @@ export declare const parseAppointmentResourceId: (value: unknown) => Result<Appo
 export declare const parseAppointmentReservationId: (value: unknown) => Result<AppointmentReservationId, BrandedIdParseError>;
 export declare const parseAppointmentReservationRunId: (value: unknown) => Result<AppointmentReservationRunId, BrandedIdParseError>;
 export declare const parseAttendeeId: (value: unknown) => Result<AttendeeId, BrandedIdParseError>;
+export declare const parseEventRegistrationCommandId: (value: unknown) => Result<EventRegistrationCommandId, BrandedIdParseError>;
+export declare const parseEventRegistrationCommandRowId: (value: unknown) => Result<EventRegistrationCommandRowId, BrandedIdParseError>;
+export declare const parseEventRegistrationProjectionClaimToken: (value: unknown) => Result<EventRegistrationProjectionClaimToken, BrandedIdParseError>;
 export declare const parseDatedOfferingCapacityHoldId: (value: unknown) => Result<DatedOfferingCapacityHoldId, BrandedIdParseError>;
 export declare const parseDatedOfferingCapacityHoldAuditRef: (value: unknown) => Result<DatedOfferingCapacityHoldAuditRef, BrandedIdParseError>;
 export declare const parseDatedOfferingRevocationAuditEventId: (value: unknown) => Result<DatedOfferingRevocationAuditEventId, BrandedIdParseError>;

package/dist/_dts/core/src/event-booking-offer-parser.d.ts

@@ -0,0 +1,82 @@
+import { type EventPricing } from './event-booking-offer';
+import { type CentsParseError } from './money-input';
+import { type Result } from './result';
+import { type ReadonlyNonEmptyArray } from './non-empty-array';
+export type EventPricingOptionParseInput = Readonly<{
+    id: unknown;
+    name: unknown;
+    description: unknown;
+    priceAmount: unknown;
+    isActive: unknown;
+    sortOrder: unknown;
+    capacityLimit: unknown;
+    saleStartsAt: unknown;
+    saleEndsAt: unknown;
+    attendanceScope: unknown;
+    recipeIdentifier: unknown;
+}>;
+export type EventPricingParseInput = Readonly<{
+    pricingStrategy: unknown;
+    currency: unknown;
+    singlePriceAmount: unknown;
+    slidingMinAmount: unknown;
+    slidingMaxAmount: unknown;
+    slidingSuggestedAmount: unknown;
+    options: unknown;
+}>;
+export type EventPricingParseIssue = Readonly<{
+    kind: 'invalid_strategy';
+    value: unknown;
+}> | Readonly<{
+    kind: 'invalid_currency';
+    value: unknown;
+}> | Readonly<{
+    kind: 'unexpected_value';
+    field: AmountField | 'options';
+}> | Readonly<{
+    kind: 'invalid_amount';
+    field: AmountField;
+    error: CentsParseError;
+}> | Readonly<{
+    kind: 'invalid_sliding_range';
+}> | Readonly<{
+    kind: 'suggested_outside_range';
+}> | Readonly<{
+    kind: 'tiered_options_empty';
+}> | Readonly<{
+    kind: 'invalid_option';
+    index: number;
+    issue: EventPricingOptionParseIssue;
+}>;
+export type EventPricingOptionParseIssue = Readonly<{
+    kind: 'invalid_id';
+}> | Readonly<{
+    kind: 'invalid_name';
+}> | Readonly<{
+    kind: 'invalid_description';
+}> | Readonly<{
+    kind: 'invalid_price';
+    error: CentsParseError;
+}> | Readonly<{
+    kind: 'invalid_active';
+}> | Readonly<{
+    kind: 'invalid_sort_order';
+}> | Readonly<{
+    kind: 'invalid_capacity';
+}> | Readonly<{
+    kind: 'invalid_sale_start';
+}> | Readonly<{
+    kind: 'invalid_sale_end';
+}> | Readonly<{
+    kind: 'invalid_sale_window';
+}> | Readonly<{
+    kind: 'invalid_object';
+}> | Readonly<{
+    kind: 'invalid_attendance_scope';
+}> | Readonly<{
+    kind: 'invalid_recipe_identifier';
+}>;
+export type NonEmptyEventPricingIssues<TIssue> = ReadonlyNonEmptyArray<TIssue>;
+type AmountField = 'singlePriceAmount' | 'slidingMinAmount' | 'slidingMaxAmount' | 'slidingSuggestedAmount';
+export declare function parseEventPricing(input: EventPricingParseInput): Result<EventPricing, NonEmptyEventPricingIssues<EventPricingParseIssue>>;
+export {};

package/dist/_dts/core/src/event-booking-offer.d.ts

@@ -0,0 +1,89 @@
+import type { PricingOptionId } from './branded';
+import type { CurrencyCode } from './currency-format';
+import type { NonNegativeCents, PositiveCents } from './money-input';
+import { type Result } from './result';
+export declare const EVENT_PRICING_STRATEGIES: readonly ["free", "single", "tiered", "sliding_scale"];
+export type EventPricingStrategy = (typeof EVENT_PRICING_STRATEGIES)[number];
+export type EventBookingRequirement = 'none' | 'required';
+export type EventPricingAttendanceScope = 'in_person' | 'online' | 'both';
+export type EventPricingOption = Readonly<{
+    id: PricingOptionId;
+    name: string;
+    description: string | null;
+    priceAmount: NonNegativeCents;
+    isActive: boolean;
+    sortOrder: number;
+    capacityLimit: number | null;
+    saleStartsAt: string | null;
+    saleEndsAt: string | null;
+    attendanceScope: EventPricingAttendanceScope;
+    recipeIdentifier: string | null;
+}>;
+export type NonEmptyEventPricingOptions<TOption> = readonly [
+    TOption,
+    ...TOption[]
+];
+export type EventPricingValueTypes = Readonly<{
+    currency: unknown;
+    positiveAmount: unknown;
+    nonNegativeAmount: unknown;
+    option: unknown;
+}>;
+export type CanonicalEventPricingValueTypes = Readonly<{
+    currency: CurrencyCode;
+    positiveAmount: PositiveCents;
+    nonNegativeAmount: NonNegativeCents;
+    option: EventPricingOption;
+}>;
+export type EventFreePricing<TCurrency = CurrencyCode> = Readonly<{
+    kind: 'free';
+    currency: TCurrency;
+}>;
+export type EventSinglePricing<TCurrency = CurrencyCode, TPositiveAmount = PositiveCents> = Readonly<{
+    kind: 'single';
+    currency: TCurrency;
+    amount: TPositiveAmount;
+}>;
+export type EventTieredPricing<TCurrency = CurrencyCode, TOption = EventPricingOption> = Readonly<{
+    kind: 'tiered';
+    currency: TCurrency;
+    options: NonEmptyEventPricingOptions<TOption>;
+}>;
+export type EventSlidingScalePricing<TCurrency = CurrencyCode, TPositiveAmount = PositiveCents, TNonNegativeAmount = NonNegativeCents> = Readonly<{
+    kind: 'sliding_scale';
+    currency: TCurrency;
+    minimum: TNonNegativeAmount;
+    maximum: TPositiveAmount;
+    suggested: TNonNegativeAmount | null;
+}>;
+export type EventPricing<TValues extends EventPricingValueTypes = CanonicalEventPricingValueTypes> = EventFreePricing<TValues['currency']> | EventSinglePricing<TValues['currency'], TValues['positiveAmount']> | EventTieredPricing<TValues['currency'], TValues['option']> | EventSlidingScalePricing<TValues['currency'], TValues['positiveAmount'], TValues['nonNegativeAmount']>;
+export type EventBookingOffer<TPaymentTerms, TValues extends EventPricingValueTypes = CanonicalEventPricingValueTypes> = Readonly<{
+    bookingRequirement: 'none';
+    pricing: EventFreePricing<TValues['currency']>;
+    paymentTerms: TPaymentTerms;
+}> | Readonly<{
+    bookingRequirement: 'required';
+    pricing: EventPricing<TValues>;
+    paymentTerms: TPaymentTerms;
+}>;
+export type EventBookingOfferIssue = Readonly<{
+    kind: 'invalid_booking_requirement';
+    value: unknown;
+}> | Readonly<{
+    kind: 'paid_without_registration';
+}>;
+export declare function createEventBookingOffer<TPaymentTerms, TValues extends EventPricingValueTypes>(input: Readonly<{
+    bookingRequirement: unknown;
+    pricing: EventPricing<TValues>;
+    paymentTerms: TPaymentTerms;
+}>): Result<EventBookingOffer<TPaymentTerms, TValues>, EventBookingOfferIssue>;
+type PayableEventPricingValues = Readonly<{
+    currency: unknown;
+    positiveAmount: number;
+    nonNegativeAmount: number;
+    option: Readonly<{
+        priceAmount: number;
+    }>;
+}>;
+export declare function eventPricingRequiresPayment<TValues extends PayableEventPricingValues>(pricing: EventPricing<TValues>): boolean;
+export {};

package/dist/_dts/core/src/event-page-surface-subject.d.ts

@@ -15,35 +15,93 @@ export type EventPageSurfaceSubjectRefWire = Readonly<{
     eventOfferingId: string;
 }>;
 export type EventPageSurfaceBookingScope = 'single_occurrence' | 'whole_series';
+/**
+ * Which renderer owns the URLs a page surface fronts.
+ *
+ * The site's Event destination policy, read through this subject's preset,
+ * settles this before any public Event record is loaded. Carrying it on the
+ * subject is what lets a route tell "this system-managed Event has no dates to
+ * show" apart from "this URL was never a system-managed Event", so a run whose
+ * public facts are withheld cannot quietly hand its URL back to whatever CMS
+ * content sits underneath it.
+ *
+ * Optional for now: the wire declares it, and a surface that has not been given
+ * one leaves the routed Event record as the only authority, exactly as before.
+ */
+export type EventPageSurfaceDestinationMode = 'cms-managed' | 'system-managed';
 export type EventSeriesPageSurfaceSubject = Readonly<{
     kind: 'eventSeries';
     eventSeriesId: EventSeriesId;
     bookingScope: 'single_occurrence';
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
 }> | Readonly<{
     kind: 'eventSeries';
     eventSeriesId: EventSeriesId;
     bookingScope: 'whole_series';
     isWholeSeriesBooking: true;
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
 }>;
 export type EventSeriesPageSurfaceSubjectWire = Readonly<{
     kind: 'eventSeries';
     eventSeriesId: string;
     bookingScope: 'single_occurrence';
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
 }> | Readonly<{
     kind: 'eventSeries';
     eventSeriesId: string;
     bookingScope: 'whole_series';
     isWholeSeriesBooking: true;
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
 }>;
-export type EventPageSurfaceSubject = EventSeriesPageSurfaceSubject | Readonly<{
+/**
+ * An offering page, and the runs it speaks for.
+ *
+ * `catalogueEventSeriesIds` is the offering's catalogue: every run it has,
+ * whatever the run's lifecycle and wherever the run's content is published. A
+ * finished run belongs here, because it is the informational fallback a parent
+ * page shows when nothing is bookable; so does a run that was given its own
+ * authored page, because the chooser links to that page rather than pretending
+ * the run is not the offering's.
+ *
+ * That is deliberately *not* the same question as which runs' content this
+ * page renders. Content ownership is settled where the offering's route is
+ * projected, and it is right for it to exclude an independently authored run.
+ * Answering both questions with one list is how the narrower answer ends up
+ * deciding whether the offering has anything on at all.
+ *
+ * `bookingScope` is read off the offering's own runs rather than assumed: an
+ * offering can front an ordinary Event as well as a whole-series one.
+ * `isWholeSeriesBooking` is derived from it, exactly as it is for a series
+ * subject, because a page's data loaders can only branch on a flag.
+ */
+export type EventOfferingPageSurfaceSubject = Readonly<{
     kind: 'eventOffering';
     eventOfferingId: EventOfferingId;
-    availableEventSeriesIds: readonly EventSeriesId[];
+    catalogueEventSeriesIds: readonly EventSeriesId[];
+    bookingScope: 'single_occurrence';
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
+}> | Readonly<{
+    kind: 'eventOffering';
+    eventOfferingId: EventOfferingId;
+    catalogueEventSeriesIds: readonly EventSeriesId[];
+    bookingScope: 'whole_series';
+    isWholeSeriesBooking: true;
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
 }>;
+export type EventPageSurfaceSubject = EventSeriesPageSurfaceSubject | EventOfferingPageSurfaceSubject;
 export type EventPageSurfaceSubjectWire = EventSeriesPageSurfaceSubjectWire | Readonly<{
     kind: 'eventOffering';
     eventOfferingId: string;
-    availableEventSeriesIds: readonly string[];
+    catalogueEventSeriesIds: readonly string[];
+    bookingScope: 'single_occurrence';
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
+}> | Readonly<{
+    kind: 'eventOffering';
+    eventOfferingId: string;
+    catalogueEventSeriesIds: readonly string[];
+    bookingScope: 'whole_series';
+    isWholeSeriesBooking: true;
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
 }>;
 export type EventPageSurfaceSubjectParseError = Readonly<{
     kind: 'notObject';
@@ -59,7 +117,26 @@ export type EventPageSurfaceSubjectParseError = Readonly<{
 }> | Readonly<{
     kind: 'invalidEventOfferingId';
     error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalidEventOfferingBookingScope';
+    bookingScope: unknown;
+}> | Readonly<{
+    kind: 'invalidEventOfferingCatalogue';
+    catalogue: unknown;
 }>;
-export declare function createEventSeriesPageSurfaceSubject(eventSeriesId: EventSeriesId, bookingScope: EventPageSurfaceBookingScope): EventSeriesPageSurfaceSubject;
+export declare function createEventSeriesPageSurfaceSubject(eventSeriesId: EventSeriesId, bookingScope: EventPageSurfaceBookingScope, eventDestinationMode?: EventPageSurfaceDestinationMode): EventSeriesPageSurfaceSubject;
+export declare function createEventOfferingPageSurfaceSubject(eventOfferingId: EventOfferingId, input: Readonly<{
+    catalogueEventSeriesIds: readonly EventSeriesId[];
+    bookingScope: EventPageSurfaceBookingScope;
+    eventDestinationMode?: EventPageSurfaceDestinationMode;
+}>): EventOfferingPageSurfaceSubject;
+/**
+ * Read the destination mode off a wire value.
+ *
+ * Absent or unrecognised reads as absent, which leaves the routed Event record
+ * as the only authority — the behaviour every caller had before the field
+ * existed.
+ */
+export declare function parseEventPageSurfaceDestinationMode(value: unknown): EventPageSurfaceDestinationMode | undefined;
 export declare function parseEventPageSurfaceSubject(value: unknown): Result<EventPageSurfaceSubject, EventPageSurfaceSubjectParseError>;
 export declare function toEventPageSurfaceSubjectWire(subject: EventPageSurfaceSubject): EventPageSurfaceSubjectWire;

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

@@ -1,118 +1,109 @@
-import { type CurrencyDecimals } from "./currency-format";
-export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types", "sliding_scale"];
-export type EventPricingMode = (typeof EVENT_PRICING_MODES)[number];
-export type PublicEventPricingType = "free" | "paid" | "external";
-export type PublicWholeSeriesPriceDisplay = Readonly<{
-    kind: "free";
-    currency: string;
-}> | Readonly<{
-    kind: "exact";
-    amount: number;
-    currency: string;
-}> | Readonly<{
-    kind: "from";
-    amount: number;
-    currency: string;
+import type { EventPricing, EventPricingStrategy } from './event-booking-offer';
+import { type CurrencyDecimals } from './currency-format';
+import { type PlanningClock } from './planner';
+export type PublicEventPricingType = 'free' | 'paid' | 'external';
+export type PublicEventPricingOptionAvailability = Readonly<{
+    kind: 'available';
+    remainingPlaces: number | null;
 }> | Readonly<{
-    kind: "range";
-    minAmount: number;
-    maxAmount: number;
-    currency: string;
-}> | Readonly<{
-    kind: "mixed";
-    paidFromAmount: number;
-    paidToAmount: number;
-    currency: string;
-}> | Readonly<{
-    kind: "unavailable";
-    currency: string;
+    kind: 'unavailable';
+    reason: 'inactive' | 'not_on_sale_yet' | 'sale_ended' | 'sold_out' | 'attendance_mode_unavailable' | 'overallCapacityUnavailable';
+    remainingPlaces: number | null;
+}>;
+export type PublicEventPricingOption = Readonly<{
+    id: string;
+    name: string;
+    description: string | null;
+    priceAmount: number;
+    isActive: boolean;
+    sortOrder: number;
+    attendanceScope: 'in_person' | 'online' | 'both';
+    saleStartsAt: string | null;
+    saleEndsAt: string | null;
+    availability: PublicEventPricingOptionAvailability;
 }>;
 export type PublicEventFreePriceDisplay = Readonly<{
-    kind: "free";
+    kind: 'free';
     currency: string;
 }>;
 export type PublicEventExactPriceDisplay = Readonly<{
-    kind: "exact";
+    kind: 'exact';
     amount: number;
     currency: string;
 }>;
 export type PublicEventExternalPriceDisplay = Readonly<{
-    kind: "external";
+    kind: 'external';
     label: string;
 }>;
-export type PublicEventTicketTypePriceDisplay = PublicEventFreePriceDisplay | PublicEventExactPriceDisplay | Readonly<{
-    kind: "from";
+export type PublicEventPricingOptionPriceDisplay = PublicEventFreePriceDisplay | PublicEventExactPriceDisplay | Readonly<{
+    kind: 'from';
     amount: number;
     currency: string;
 }> | Readonly<{
-    kind: "range";
+    kind: 'range';
     minAmount: number;
     maxAmount: number;
+    suggestedAmount?: number | null;
     currency: string;
 }> | Readonly<{
-    kind: "mixed";
+    kind: 'mixed';
     paidFromAmount: number;
     paidToAmount: number;
     currency: string;
 }> | Readonly<{
-    kind: "unavailable";
+    kind: 'unavailable';
     currency: string;
 }>;
-export type PublicEventPriceDisplay = PublicEventTicketTypePriceDisplay | PublicEventExternalPriceDisplay | Readonly<{
-    kind: "whole_series";
-    display: PublicWholeSeriesPriceDisplay;
-}>;
-export type PublicEventPricing<TTicketType = never> = Readonly<{
-    kind: "drop_in";
+export type PublicEventPriceDisplay = PublicEventPricingOptionPriceDisplay | PublicEventExternalPriceDisplay;
+export type SharedPricingPriceDisplay = PublicEventPricingOptionPriceDisplay;
+type PublicEventPricingValues = Readonly<{
     currency: string;
-    display: PublicEventFreePriceDisplay;
-}> | Readonly<{
-    kind: "free_registration";
-    currency: string;
-    display: PublicEventFreePriceDisplay;
-}> | Readonly<{
-    kind: "single_paid";
-    amount: number;
-    currency: string;
-    display: PublicEventExactPriceDisplay;
-}> | Readonly<{
-    kind: "ticket_types";
-    currency: string;
-    ticketTypes: readonly TTicketType[];
-    display: PublicEventTicketTypePriceDisplay;
-}> | Readonly<{
-    kind: "sliding_scale";
-    minAmount: number;
-    maxAmount: number;
-    suggestedAmount: number | null;
-    currency: string;
-    display: Readonly<{
-        kind: "range";
-        minAmount: number;
-        maxAmount: number;
-        currency: string;
-    }>;
-}> | Readonly<{
-    kind: "whole_series";
-    display: Readonly<{
-        kind: "whole_series";
-        display: PublicWholeSeriesPriceDisplay;
-    }>;
-}> | Readonly<{
-    kind: "external";
-    display: Readonly<{
-        kind: "external";
-        label: string;
+    positiveAmount: number;
+    nonNegativeAmount: number;
+    option: PublicEventPricingOption;
+}>;
+export type PublicManagedEventPricing = EventPricing<PublicEventPricingValues>;
+export type PublicEventPricing = PublicManagedEventPricing | Readonly<{
+    kind: 'external';
+    label: string;
+}>;
+/** Capacity closes booking, but does not make an otherwise eligible price unknown. */
+export declare function isPublicEventPricingOptionDisplayable(option: Pick<PublicEventPricingOption, 'isActive' | 'availability'>): boolean;
+export declare function publicEventPricingDisplay(pricing: PublicEventPricing): PublicEventPriceDisplay;
+export declare function publicEventPricingType(pricing: PublicEventPricing): PublicEventPricingType;
+export declare function publicEventPricingCurrency(pricing: PublicEventPricing): string | null;
+export declare function publicEventScalarPrice(pricing: PublicEventPricing): number | null;
+export declare function publicEventPricingStrategy(pricing: PublicEventPricing): EventPricingStrategy | undefined;
+export declare function publicEventPricingOptions(pricing: PublicEventPricing): readonly PublicEventPricingOption[];
+export type CanonicalEventPriceDisplay = PublicEventPricingOptionPriceDisplay;
+type DisplayableEventPricingValues = Readonly<{
+    currency: string;
+    positiveAmount: number;
+    nonNegativeAmount: number;
+    option: Readonly<{
+        priceAmount: number;
+        isActive: boolean;
     }>;
 }>;
-export declare function isEventPricingMode(value: unknown): value is EventPricingMode;
-export declare function publicEventPricingDisplay(pricing: PublicEventPricing<unknown>): PublicEventPriceDisplay;
-export declare function publicEventPricingType(pricing: PublicEventPricing<unknown>): PublicEventPricingType;
-export declare function publicEventPricingCurrency(pricing: PublicEventPricing<unknown>): string | null;
-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 PricingOptionsDisplayPurpose = 'configured' | 'available_now';
+export type PricingOptionForDisplay = Readonly<{
+    priceAmount: number;
+    isActive: boolean;
+    saleStartsAt?: string | null;
+    saleEndsAt?: string | null;
+}>;
+export type PricingOptionSaleWindowState = 'open' | 'not_started' | 'ended';
+export declare function resolvePricingOptionSaleWindowState(option: Pick<PricingOptionForDisplay, 'saleStartsAt' | 'saleEndsAt'>, now: Date): PricingOptionSaleWindowState;
+export declare function resolveExactOrFreePriceDisplay(amount: number | null | undefined, currency: string): PublicEventPricingOptionPriceDisplay;
+export declare function resolvePricingOptionsPriceDisplay(input: Readonly<{
+    options: readonly PricingOptionForDisplay[];
+    currency: string;
+    purpose: PricingOptionsDisplayPurpose;
+    now?: Date;
+    clock?: PlanningClock;
+}>): PublicEventPricingOptionPriceDisplay;
+/** Derives configured price presentation directly from canonical pricing. */
+export declare function canonicalEventPricingDisplay<TValues extends DisplayableEventPricingValues>(pricing: EventPricing<TValues>): CanonicalEventPriceDisplay;
 export type FormatBookingPriceDisplayOptions = Readonly<{
     /** Trailing-decimal policy passed through to the currency formatter. */
     decimals?: CurrencyDecimals;
@@ -126,6 +117,7 @@ export type FormatBookingPriceDisplayOptions = Readonly<{
  * 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;
+export declare function formatBookingPriceDisplay(display: PublicEventPriceDisplay, options?: FormatBookingPriceDisplayOptions): string;
 /** Render an event's price directly from its pricing value. */
-export declare function formatEventPricing(pricing: PublicEventPricing<unknown>, options?: FormatBookingPriceDisplayOptions): string;
+export declare function formatEventPricing(pricing: PublicEventPricing, options?: FormatBookingPriceDisplayOptions): string;
+export {};

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

@@ -6,6 +6,8 @@ export * from './demo-claim-access';
 export * from './demo-lifecycle-status';
 export * from './demo-runtime';
 export * from './collections';
+export * from './event-booking-offer';
+export * from './event-booking-offer-parser';
 export * from './event-pricing';
 export * from './event-page-surface-subject';
 export * from './event-page-selection';
@@ -60,5 +62,6 @@ 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';
 export { isValidBookingTimeZone, parseBookingTimeZone, type BookingTimeZone, type BookingTimeZoneParseError, } from './booking-time-zone';
+export { CANCELLED_SESSION_STATUS, firstLiveRunSessionStartMs, isWholeSeriesRegistrationOpen, orderedLiveRunSessions, resolveWholeSeriesBookingPhase, resolveWholeSeriesRunLifecycle, type WholeSeriesBookingPhase, type WholeSeriesRunLifecycle, type WholeSeriesScheduleSession, } from './whole-series-run-schedule';
 export * from './booking-verticals';
 export * from './event-series-behaviour';

package/dist/_dts/core/src/non-empty-array.d.ts

@@ -1,4 +1,7 @@
 import { type Result } from './result';
 export type NonEmptyArray<T> = [T, ...T[]];
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
 export declare function fromArray<T>(items: readonly T[]): Result<NonEmptyArray<T>, 'empty_array'>;
 export declare function mapNonEmptyArray<T, U>(items: NonEmptyArray<T>, map: (item: T, index: number) => U): NonEmptyArray<U>;
+export declare function fromReadonlyArray<T>(items: readonly T[]): Result<ReadonlyNonEmptyArray<T>, 'empty_array'>;
+export declare function mapReadonlyNonEmptyArray<T, U>(items: ReadonlyNonEmptyArray<T>, map: (item: T, index: number) => U): ReadonlyNonEmptyArray<U>;