@fanfare-io/fanfare-sdk-solid 0.19.0 → 0.20.0

package/README.md

@@ -42,10 +42,10 @@ Solid applications can use `FanfareProvider`, `ExperienceWidget`, and `useExperi
 
 ## Selection
 
-Some experiences capture which product and variant a consumer gets. In this release the Solid
-package exports the two building blocks of that picker for you to compose in a granted slot; the
-widget-integrated flow, where `ExperienceWidget` renders the picker on its own, ships in a later
-release.
+Some experiences capture which product and variant a consumer gets. `ExperienceWidget` renders that
+flow itself on a granted sequence — the pick, a mystery grant's reveal, the wait for an assignment
+and the locked summary — and the package also exports the two building blocks of the picker for you
+to compose in a granted slot instead.
 
 - `ProductSelector` — loads a catalogue through its `loadOptions` callback, renders the product
   rows, the chosen product's option chips and the resolved variant, and reports a complete
@@ -63,10 +63,20 @@ Selection is configured per sequence, under either checkout arrangement. With me
 (`external`) checkout the pick is the host's to cart: the slot that composed `ProductSelector` holds
 the resolved `{ productId, variantId }` pair and the catalogue it came from, and carries it into its
 own checkout. With Fanfare (`internal`) checkout the granted panel continues into Fanfare's own
-checkout instead, under both checkout modes, `at_end` and `pre_auth`. Entry-time picking (choosing
-before you enter) is not yet available. The React adapter's widget-integrated hand-off — the
-`onCheckoutClick(details?: SelectionCheckoutDetails)` callback — ships with the widget-integrated
-flow, so Solid exports no equivalent type yet.
+checkout instead, under both checkout modes, `at_end` and `pre_auth`. Entry-time picking is live:
+when the server declares that a draw, timed release or auction bid needs a product choice before
+entry, the module renders the picker and `enter` / `bid` carry the pair. A host reaching the view
+directly checks `"loadSelectionOptions" in view` for the required arm and reads
+`view.selection.required` for display. On the widget-rendered flow the hand-off arrives through
+`onCheckoutClick(details?: SelectionCheckoutDetails)`: the pick the grant settled on, with the
+catalogue product and variant behind it whenever the widget has loaded them. For external checkout,
+use their `externalReference` identities when provided, rather than reconstructing identity from
+handles, SKUs or display options. Shopify references identify the product and real variant even
+when the default variant has empty option values. Handle absent references before starting checkout;
+these fields require a compatible backend and SDK release. Returning a rejected promise returns the consumer
+to the CTA with generic inline copy, so a hand-off that never happened is never reported as started.
+Every local pick-surface transition is also announced on the widget root as a bubbling, composed
+`fanfare:selection-change` event.
 
 Three integration tiers, in increasing specificity:
 

package/dist/components/compositions/granted-panel.d.ts

@@ -1,4 +1,7 @@
+import { ClaimableSettlement, PreAuthSettlement } from '@fanfare-io/fanfare-sdk-core/experiences';
+import { GrantedSelection, SelectionChoice, SelectionDraft, SelectionOptions } from '@fanfare-io/fanfare-sdk-core/selections';
 import { JSX } from 'solid-js';
+import { SelectionCheckoutDetails, SelectionDisplay } from '../../lib/selection-display';
 export interface GrantedPanelProps {
     label: JSX.Element;
     fallbackMessage: JSX.Element;
@@ -10,9 +13,56 @@ export interface GrantedPanelProps {
      * payment countdown states what the consumer owes, so a synthesised one is worse than none.
      */
     detail?: JSX.Element;
-    onCtaClick?: () => void;
+    /**
+     * Activated by the checkout CTA, carrying the pick the grant settled on and the catalogue
+     * objects behind it whenever this panel has loaded them.
+     */
+    onCtaClick?: (details?: SelectionCheckoutDetails) => void | Promise<void>;
     class?: string;
     className?: string;
+    /** Granted-state selection: drives the pick, reveal, wait and summary states. */
+    selection?: GrantedSelection | null;
+    /**
+     * How the win settles. Selects the confirm label and which affordance sits beneath a resolved
+     * summary; absent leaves the CTA exactly as the caller wired it.
+     */
+    settlement?: ClaimableSettlement | PreAuthSettlement;
+    /**
+     * Parent binds the view's option loader; fetch-on-open only. Must be referentially stable — a
+     * new identity re-fetches the catalogue.
+     */
+    loadSelectionOptions?: () => Promise<SelectionOptions>;
+    /**
+     * Parent binds the view's selection submit; resolves when the pin is written and rejects on
+     * failure — the panel keys its pick UI on settle and shows the failure through `selectError`.
+     *
+     * The promise must resolve only once the journey atom carries the new selection: the pick
+     * surface collapses on the `selection` prop flip, so a promise that settles ahead of the atom
+     * re-enables the confirm control over a pick that has already been taken.
+     */
+    onConfirmSelection?: (choice: SelectionChoice) => Promise<void>;
+    /**
+     * Reports every local pick-surface transition, product-only drafts included, so the widget can
+     * emit the page-bridge selection-change event; `onConfirmSelection` stays the only settled-pair
+     * channel.
+     */
+    onDraftChange?: (draft: SelectionDraft) => void;
+    /** Heading copy for the pick state; the generic selection title stands when absent. */
+    selectionTitle?: JSX.Element;
+    /** Helper copy under the pick heading; a reveal supplies its own prompt when absent. */
+    selectionDescription?: JSX.Element;
+    /**
+     * Display strings for the resolved summary. Absent on a consumer-chosen resolution renders no
+     * summary at all: a locked line with no item detail states less than nothing.
+     */
+    selectionDisplay?: SelectionDisplay | null;
+    /**
+     * Locked copy for a resolved summary; modules pass "checkout" once checkout has started. Passing
+     * it also freezes the pick: the summary reads out locked with this reason and offers no change.
+     */
+    selectionLockedReason?: "checkout" | "final";
+    /** Inline error from the parent's selection submit. */
+    selectError?: string | null;
 }
 export declare function GrantedPanel(props: GrantedPanelProps): JSX.Element;
 export declare namespace GrantedPanel {

package/dist/components/internal/auction-module.d.ts

@@ -1,6 +1,9 @@
 import { AuctionBidInput, AuctionConsumerStatus } from '@fanfare-io/fanfare-sdk-core/auctions';
+import { ClaimableSettlement, PreAuthSettlement } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { AuctionDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { GrantedSelection, SelectionChoice, SelectionDraft, SelectionOptions } from '@fanfare-io/fanfare-sdk-core/selections';
 import { ReadableAtom } from 'nanostores';
+import { SelectionCheckoutDetails } from '../../lib/selection-display';
 import { OutcomeAction } from '../compositions/outcome-panel';
 import { OutcomeReason } from '../module';
 export interface AuctionModuleProps {
@@ -27,7 +30,29 @@ export interface AuctionModuleProps {
      */
     auctionType?: "english" | "dutch";
     checkoutUrl?: string;
-    onCheckoutClick?: () => void;
+    /**
+     * Activating the checkout CTA. Receives the pick the grant settled on, with the catalogue
+     * objects behind it, whenever the panel has loaded the catalogue that carries them.
+     */
+    onCheckoutClick?: (details?: SelectionCheckoutDetails) => void | Promise<void>;
+    /** Granted-state selection arm; drives the panel's pick, reveal and summary states. */
+    grantedSelection?: GrantedSelection;
+    /** How the win settles; selects the granted confirm label and payment affordance. */
+    settlement?: ClaimableSettlement | PreAuthSettlement;
+    /** The auction captures a product choice on the entering bid, so the bid surface renders a picker. */
+    selectionRequired?: boolean;
+    /** Bound by the widget against the journey; must be referentially stable. */
+    loadSelectionOptions?: () => Promise<SelectionOptions>;
+    /** The pair the standing bid was placed for; present, it is read back instead of offered again. */
+    lockedSelection?: SelectionChoice | null;
+    /** Submits the granted pick or re-pick. */
+    onSelect?: (choice: SelectionChoice) => Promise<void>;
+    /** Every local pick-surface transition, product-only drafts included; feeds the page-bridge event. */
+    onDraftChange?: (draft: SelectionDraft) => void;
+    /** Locked copy for a resolved granted summary; "checkout" once checkout has started. */
+    selectionLockedReason?: "checkout" | "final";
+    /** Already-translated selection failure from the widget, rendered beside the acting control. */
+    selectError?: string | null;
     outcomeReason?: OutcomeReason;
     /** Host-provided action shown on the terminal panel. */
     outcomeAction?: OutcomeAction;

package/dist/components/internal/draw-module.d.ts

@@ -1,5 +1,8 @@
+import { ClaimableSettlement, PreAuthSettlement } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { DrawDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { GrantedSelection, SelectionAvailability, SelectionChoice, SelectionDraft, SelectionOptions } from '@fanfare-io/fanfare-sdk-core/selections';
 import { ReadableAtom } from 'nanostores';
+import { SelectionCheckoutDetails } from '../../lib/selection-display';
 import { OutcomeAction } from '../compositions/outcome-panel';
 import { OutcomeReason } from '../module';
 export interface DrawModuleProps {
@@ -7,7 +10,8 @@ export interface DrawModuleProps {
     sequencePhase: "enterable" | "participating" | "settling" | "granted" | "ended";
     canEnter: boolean;
     canLeave: boolean;
-    onEnter: () => Promise<void>;
+    /** Enter action handler; carries the entry pick on a selection-bearing draw. */
+    onEnter: (selection?: SelectionChoice) => Promise<void>;
     onLeave: () => Promise<void>;
     isEntering: boolean;
     isLeaving: boolean;
@@ -15,7 +19,35 @@ export interface DrawModuleProps {
     grant?: string;
     expiresAt?: number | Date;
     checkoutUrl?: string;
-    onCheckoutClick?: () => void;
+    /**
+     * Activating the checkout CTA. Receives the pick the grant settled on, with the catalogue
+     * objects behind it, whenever the panel has loaded the catalogue that carries them.
+     */
+    onCheckoutClick?: (details?: SelectionCheckoutDetails) => void | Promise<void>;
+    /** Granted-state selection arm; drives the panel's pick, reveal and summary states. */
+    grantedSelection?: GrantedSelection;
+    /** How the win settles; selects the granted confirm label and payment affordance. */
+    settlement?: ClaimableSettlement | PreAuthSettlement;
+    /** The draw captures a product choice at entry, so the entry branch renders the picker. */
+    selectionRequired?: boolean;
+    /** Bound by the widget against the journey; must be referentially stable. */
+    loadSelectionOptions?: () => Promise<SelectionOptions>;
+    /** The choice already recorded for this entry, shown while the consumer waits. */
+    recordedSelection?: SelectionChoice | null;
+    /** Live availability of the recorded pick, so a sold-out choice is said rather than discovered. */
+    selectionAvailability?: SelectionAvailability;
+    /** Submits a changed choice while waiting. */
+    onSelectionChange?: (choice: SelectionChoice) => Promise<void>;
+    /** Submits the granted pick or re-pick. */
+    onSelect?: (choice: SelectionChoice) => Promise<void>;
+    /** Every local pick-surface transition, product-only drafts included; feeds the page-bridge event. */
+    onDraftChange?: (draft: SelectionDraft) => void;
+    /** Locked copy for a resolved granted summary; "checkout" once checkout has started. */
+    selectionLockedReason?: "checkout" | "final";
+    /** Already-translated selection failure from the widget, rendered beside the acting control. */
+    selectError?: string | null;
+    /** The refusal code behind `selectError`; a stock refusal refetches the catalogue once. */
+    selectErrorCode?: string | null;
     outcomeReason?: OutcomeReason;
     /** Host-provided action shown on the terminal panel. */
     outcomeAction?: OutcomeAction;

package/dist/components/internal/queue-module.d.ts

@@ -1,5 +1,8 @@
+import { ClaimableSettlement, PreAuthSettlement } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { QueueDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { GrantedSelection, SelectionChoice, SelectionDraft, SelectionOptions } from '@fanfare-io/fanfare-sdk-core/selections';
 import { ReadableAtom } from 'nanostores';
+import { SelectionCheckoutDetails } from '../../lib/selection-display';
 import { OutcomeAction } from '../compositions/outcome-panel';
 import { OutcomeReason } from '../module';
 export interface QueueModuleProps {
@@ -16,7 +19,25 @@ export interface QueueModuleProps {
     grant?: string;
     expiresAt?: number | Date;
     checkoutUrl?: string;
-    onCheckoutClick?: () => void;
+    /**
+     * Activating the checkout CTA. Receives the pick the grant settled on, with the catalogue
+     * objects behind it, whenever the panel has loaded the catalogue that carries them.
+     */
+    onCheckoutClick?: (details?: SelectionCheckoutDetails) => void | Promise<void>;
+    /** Granted-state selection arm; drives the panel's pick, reveal and summary states. */
+    grantedSelection?: GrantedSelection;
+    /** How the win settles; selects the granted confirm label and payment affordance. */
+    settlement?: ClaimableSettlement | PreAuthSettlement;
+    /** Bound by the widget against the journey; must be referentially stable. */
+    loadSelectionOptions?: () => Promise<SelectionOptions>;
+    /** Submits the granted pick or re-pick. */
+    onSelect?: (choice: SelectionChoice) => Promise<void>;
+    /** Every local pick-surface transition, product-only drafts included; feeds the page-bridge event. */
+    onDraftChange?: (draft: SelectionDraft) => void;
+    /** Locked copy for a resolved granted summary; "checkout" once checkout has started. */
+    selectionLockedReason?: "checkout" | "final";
+    /** Already-translated selection failure from the widget, rendered beside the acting control. */
+    selectError?: string | null;
     outcomeReason?: OutcomeReason;
     /** Host-provided action shown on the terminal panel. */
     outcomeAction?: OutcomeAction;

package/dist/components/internal/selection/index.d.ts

@@ -9,5 +9,5 @@
  */
 export { ProductSelector } from './product-selector';
 export type { ProductSelectorHandle, ProductSelectorProps } from './product-selector';
-export { SelectionSummary } from './selection-summary';
+export { SELECTION_LOCKED_COPY, SelectionSummary } from './selection-summary';
 export type { SelectionLockedReason, SelectionSummaryProps } from './selection-summary';

package/dist/components/internal/selection/selection-branches.d.ts

@@ -0,0 +1,69 @@
+import { GrantedSelection, SelectionAvailability, SelectionChoice, SelectionDraft, SelectionOptions } from '@fanfare-io/fanfare-sdk-core/selections';
+import { JSX } from 'solid-js';
+import { ProductSelectorHandle } from './product-selector';
+/** Widened so a selection-bearing panel stacks its rows instead of clipping them at the card cap. */
+export declare const SELECTION_PANEL_CLASS = "ff:max-h-none ff:overflow-visible";
+/** The granted-arm selection props every distribution module threads into its granted panel. */
+export interface GrantedPickProps {
+    grantedSelection?: GrantedSelection;
+    loadSelectionOptions?: () => Promise<SelectionOptions>;
+    onSelect?: (choice: SelectionChoice) => Promise<void>;
+    selectionLockedReason?: "checkout" | "final";
+}
+/**
+ * Whether the granted panel can still open a pick surface, which is the only place the panel's
+ * height cap may be lifted — the Confirm control below an open picker has to stay reachable.
+ *
+ * Reads its fields on call, so a module passes its own props object and gets a live answer.
+ */
+export declare function grantedPickReachable(props: GrantedPickProps): boolean;
+export interface EntrySelectionSurfaceProps {
+    /** Fetch-on-open; must be referentially stable — a new identity re-fetches the catalogue. */
+    loadOptions(): Promise<SelectionOptions>;
+    /** Already-translated heading above the picker. */
+    title: JSX.Element;
+    /** The consumer's current complete pair, or null while the pick is incomplete. */
+    onDraftSelection(choice: SelectionChoice | null): void;
+    onOptionsLoaded(options: SelectionOptions): void;
+    /** Every local transition, product-only drafts included; feeds the page-bridge event. */
+    onDraftChange?(draft: SelectionDraft): void;
+    /** Set by the CTA when it was clicked on an incomplete pick. */
+    missingChoice: boolean;
+    selectError?: string | null;
+    disabled?: boolean;
+    /** Receives the picker's imperative handle, so the CTA can move focus into an incomplete pick. */
+    ref?: (handle: ProductSelectorHandle) => void;
+}
+/**
+ * The entry picker: statically present in the branch, with no open or collapse of its own.
+ *
+ * The CTA below it stays enabled with no choice made, so the consumer finds out what is missing
+ * by acting rather than by a control that refuses to be pressed.
+ */
+export declare function EntrySelectionSurface(props: EntrySelectionSurfaceProps): JSX.Element;
+export declare namespace EntrySelectionSurface {
+    var displayName: string;
+}
+export interface RecordedSelectionSurfaceProps {
+    choice: SelectionChoice;
+    availability?: SelectionAvailability;
+    loadOptions?: () => Promise<SelectionOptions>;
+    /** Submits the new pair; rejects when the server refuses, which keeps the picker open. */
+    onSelectionChange?: (choice: SelectionChoice) => Promise<void>;
+    /** Options already in memory from a pick made earlier in this mount. */
+    loadedOptions: SelectionOptions | null;
+    onOptionsLoaded(options: SelectionOptions): void;
+    /** Every local transition, product-only drafts included; feeds the page-bridge event. */
+    onDraftChange?(draft: SelectionDraft): void;
+    selectError?: string | null;
+}
+/**
+ * The recorded pick and its re-pick, for a consumer already waiting on a result.
+ *
+ * A fresh mount has no catalogue in memory and makes no request for one: the summary states the
+ * pick generically rather than spending an entrant's request budget on prettier names.
+ */
+export declare function RecordedSelectionSurface(props: RecordedSelectionSurfaceProps): JSX.Element;
+export declare namespace RecordedSelectionSurface {
+    var displayName: string;
+}

package/dist/components/internal/selection/selection-summary.d.ts

@@ -17,6 +17,12 @@ export interface SelectionSummaryProps {
     class?: string;
     className?: string;
 }
+/** The locked-state sentence each reason reads out, so a caller never states it a second time. */
+export declare const SELECTION_LOCKED_COPY: {
+    readonly checkout: "selection.locked.checkout";
+    readonly final: "selection.locked.final";
+    readonly bid: "selection.locked.bid";
+};
 /**
  * A compact read-out of a pick that has already been captured.
  *

package/dist/components/internal/timed-release-module.d.ts

@@ -1,5 +1,8 @@
+import { ClaimableSettlement, PreAuthSettlement } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { TimedReleaseDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { GrantedSelection, SelectionAvailability, SelectionChoice, SelectionDraft, SelectionOptions } from '@fanfare-io/fanfare-sdk-core/selections';
 import { ReadableAtom } from 'nanostores';
+import { SelectionCheckoutDetails } from '../../lib/selection-display';
 import { OutcomeAction } from '../compositions/outcome-panel';
 import { OutcomeReason } from '../module';
 export interface TimedReleaseModuleProps {
@@ -7,14 +10,41 @@ export interface TimedReleaseModuleProps {
     sequencePhase: "enterable" | "participating" | "granted" | "ended";
     canEnter: boolean;
     canLeave: boolean;
-    onEnter: () => Promise<void>;
+    /** Enter action handler; carries the entry pick on a selection-bearing release. */
+    onEnter: (selection?: SelectionChoice) => Promise<void>;
     onLeave: () => Promise<void>;
     onComplete?: () => Promise<void>;
     isEntering: boolean;
     isLeaving: boolean;
     countdownTo?: Date;
     checkoutUrl?: string;
-    onCheckoutClick?: () => void;
+    /**
+     * Activating the checkout CTA. Receives the pick the grant settled on, with the catalogue
+     * objects behind it, whenever the panel has loaded the catalogue that carries them.
+     */
+    onCheckoutClick?: (details?: SelectionCheckoutDetails) => void | Promise<void>;
+    /** Granted-state selection arm; drives the panel's pick, reveal and summary states. */
+    grantedSelection?: GrantedSelection;
+    /** How the win settles; selects the granted confirm label and payment affordance. */
+    settlement?: ClaimableSettlement | PreAuthSettlement;
+    /** The release captures a product choice at entry, so the entry branch renders the picker. */
+    selectionRequired?: boolean;
+    /** Bound by the widget against the journey; must be referentially stable. */
+    loadSelectionOptions?: () => Promise<SelectionOptions>;
+    /** The choice already recorded for this entry. */
+    recordedSelection?: SelectionChoice | null;
+    /** Live availability of the recorded pick. */
+    selectionAvailability?: SelectionAvailability;
+    /** Submits the granted pick or re-pick. */
+    onSelect?: (choice: SelectionChoice) => Promise<void>;
+    /** Every local pick-surface transition, product-only drafts included; feeds the page-bridge event. */
+    onDraftChange?: (draft: SelectionDraft) => void;
+    /** Locked copy for a resolved granted summary; "checkout" once checkout has started. */
+    selectionLockedReason?: "checkout" | "final";
+    /** Already-translated selection failure from the widget, rendered beside the acting control. */
+    selectError?: string | null;
+    /** The refusal code behind `selectError`; a stock refusal refetches the catalogue once. */
+    selectErrorCode?: string | null;
     grant?: string;
     expiresAt?: number | Date;
     outcomeReason?: OutcomeReason;

package/dist/components/widgets/experience-widget.d.ts

@@ -3,11 +3,12 @@ import { SDKEvents } from '@fanfare-io/fanfare-sdk-core/events';
 import { CheckoutNextAction, FanfareCheckoutResult, JourneyHandle, JourneySnapshot, JourneyView, PaymentInput, PaymentMethodSummary, SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { BrandTheme } from '@fanfare-io/fanfare-sdk-core/theme';
 import { JSX } from 'solid-js';
+import { SelectionCheckoutDetails } from '../../lib/selection-display';
 import { WidgetVariant } from '../../theme';
 import { AuthInputMode } from '../auth/auth-input';
 import { OutcomeAction } from '../compositions/outcome-panel';
 type ParticipationType = "queue" | "draw" | "auction" | "timed_release" | "appointment";
-type EnterableSlotSequence = Extract<SequenceView, {
+export type EnterableSlotSequence = Extract<SequenceView, {
     phase: "enterable";
     mechanism: ParticipationType;
 }>;
@@ -183,6 +184,13 @@ export interface ExperienceWidgetProps {
     pageType?: BeaconPageType;
     children?: (props: ExperienceRenderProps) => JSX.Element;
     checkoutUrl?: string;
+    /**
+     * Called when the consumer activates the granted checkout CTA, with the pick the grant settled
+     * on and the catalogue objects behind it whenever the widget has loaded them. Takes precedence
+     * over `checkoutUrl`. A rejected promise returns the consumer to the CTA with generic inline
+     * copy, so a hand-off that never happened is not reported as started.
+     */
+    onCheckoutClick?: (details?: SelectionCheckoutDetails) => void | Promise<void>;
     /**
      * Action offered on terminal panels (not selected, sold out, closed), such as
      * a link back to what is still available. Omit to show none.

package/dist/components/widgets/index.d.ts

@@ -9,3 +9,4 @@
 export { ExperienceWidget, type AccessCodeSlotProps, type AuthSlotProps, type ChallengeSlotProps, type CheckoutProcessingSlotProps, type EndedSlotProps, type EnterableSlotProps, type ErrorSlotProps, type ExperienceRenderProps, type ExperienceWidgetProps, type ExperienceWidgetSlots, type ExpiredSlotProps, type GrantedSlotProps, type LoadingSlotProps, type ParticipatingSlotProps, type PaymentCollectionSlotProps, type ReceiptSlotProps, type SlotProps, type StartSlotProps, type UpcomingSlotProps, type WaitlistSlotProps, } from './experience-widget';
 export { LoadingView, StartView, UpcomingModule, WaitlistView, type LoadingViewProps, type StartViewProps, type UpcomingModuleProps, type WaitlistViewProps, } from '../internal';
 export { AppointmentModule, AuctionModule, DrawModule, QueueModule, TimedReleaseModule, type AppointmentModuleProps, type AuctionModuleProps, type DrawModuleProps, type QueueModuleProps, type TimedReleaseModuleProps, } from '../internal';
+export type { EnterableSlotSequence } from './experience-widget';

package/dist/index.d.ts

@@ -22,12 +22,13 @@ export { AccessCodeForm, ChallengeGate, EndedModule, ErrorView, GrantedPanel, Ou
 export type { AccessCodeFormProps, ChallengeGateProps, EndedModuleProps, ErrorViewProps, GrantedPanelProps, OutcomePanelProps, } from './components/compositions';
 export { ProductSelector, SelectionSummary } from './components/internal/selection';
 export type { ProductSelectorHandle, ProductSelectorProps, SelectionLockedReason, SelectionSummaryProps, } from './components/internal/selection';
+export type { SelectionCheckoutDetails } from './lib/selection-display';
 export { ExperienceWidget } from './components/widgets';
 export type { AccessCodeSlotProps, AuthSlotProps, ChallengeSlotProps, CheckoutProcessingSlotProps, EndedSlotProps, EnterableSlotProps, ErrorSlotProps, ExperienceRenderProps, ExperienceWidgetProps, ExperienceWidgetSlots, ExpiredSlotProps, GrantedSlotProps, LoadingSlotProps, ParticipatingSlotProps, PaymentCollectionSlotProps, ReceiptSlotProps, SlotProps, StartSlotProps, UpcomingSlotProps, WaitlistSlotProps, } from './components/widgets';
 export { CheckoutProcessingPanel, PaymentCollectionPanel, ReceiptPanel } from './components/checkout';
 export { LoadingView, StartView, UpcomingModule, WaitlistView } from './components/widgets';
 export type { LoadingViewProps, StartViewProps, UpcomingModuleProps, WaitlistViewProps } from './components/widgets';
 export { AppointmentModule, AuctionModule, DrawModule, QueueModule, TimedReleaseModule } from './components/widgets';
-export type { AppointmentModuleProps, AuctionModuleProps, DrawModuleProps, QueueModuleProps, TimedReleaseModuleProps, } from './components/widgets';
+export type { AppointmentModuleProps, AuctionModuleProps, DrawModuleProps, EnterableSlotSequence, QueueModuleProps, TimedReleaseModuleProps, } from './components/widgets';
 export * from './styles';
 export { registerWebComponents } from './register';