@fanfare-io/fanfare-sdk-react 0.12.0 → 0.14.0

package/dist/components/checkout/checkout-processing-panel.d.ts

@@ -1,8 +1,8 @@
 import { CheckoutProcessingSlotProps } from '../widgets/experience-widget';
 import * as React from "react";
 /**
- * Default processing panel shown for the gap between a submitted reservation checkout and the
- * server's confirmation.
+ * Default processing panel shown for the gap between a submitted checkout and the server's
+ * confirmation.
  *
  * The consumer must not navigate away while the payment settles, so the wait is announced rather
  * than shown only as motion.

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

@@ -1,4 +1,3 @@
 export { CheckoutProcessingPanel } from './checkout-processing-panel';
 export { PaymentCollectionPanel } from './payment-collection-panel';
 export { ReceiptPanel } from './receipt-panel';
-export { ReservationCheckoutPanel } from './reservation-checkout-panel';

package/dist/components/checkout/payment-collection-panel.d.ts

@@ -1,8 +1,7 @@
 import { PaymentCollectionSlotProps } from '../widgets/experience-widget';
 import * as React from "react";
 /**
- * Default payment-collection panel for pre-auth distributions, rendered both when the consumer is
- * about to enter and when a failed authorization leaves a retry open.
+ * Default payment-collection panel for pre-auth entry/re-entry and grant-keyed at-end checkout.
  *
  * The hold amount is rendered from the view's own figure — the client never derives one.
  *
@@ -15,4 +14,4 @@ import * as React from "react";
  * minted across the whole flow. An ended view carries no pending action, so the retry mount reaches
  * none of this.
  */
-export declare function PaymentCollectionPanel({ preAuthAmount, preAuthCurrencyCode, savedPaymentMethods, paymentProvider, onEnter, isEntering, intent, pendingAction, onRetryPaymentConfig, ...slotProps }: PaymentCollectionSlotProps): React.ReactElement;
+export declare function PaymentCollectionPanel(props: PaymentCollectionSlotProps): React.ReactElement;

package/dist/components/checkout/stripe-card-field.d.ts

@@ -1,7 +1,7 @@
 import { StripeClientConfig } from './stripe-client';
 /**
  * The SDK's card-entry field: a Stripe Card Element and the controller that turns it into a
- * payment-method id. It knows nothing about reservations, pre-auth, or amounts.
+ * payment-method id. It knows nothing about settlement, pre-auth, or amounts.
  *
  * `@stripe/stripe-js` is a type-only dependency across the SDK, so no vendor bytes ship in any
  * chunk. This module is the one lazy split: it is reached only through a dynamic `import()` from

package/dist/components/checkout/stripe-client.d.ts

@@ -1,11 +1,18 @@
-import { ReservationPaymentAffordance } from '@fanfare-io/fanfare-sdk-core/experiences';
+import { SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { Stripe, StripeConstructor, StripeElementStyle } from '@stripe/stripe-js';
+/** How a granted win settles, as the granted views carry it. */
+type GrantedSettlement = Extract<SequenceView, {
+    phase: "granted";
+}>["settlement"];
 /**
  * The wire block a checkout-capable view carries, reached through the adapter's declared
  * dependency on `fanfare-sdk-core` rather than the contracts package: core re-exports the contract
- * types so adapter modules never resolve `@fanfare-io/fanfare-sdk-contracts` directly.
+ * types so adapter modules never resolve `@fanfare-io/fanfare-sdk-contracts` directly. Core names
+ * the shape only within the arms that carry it, so it is read back off one of them.
  */
-type PaymentProviderConfig = NonNullable<ReservationPaymentAffordance["paymentProvider"]>;
+type PaymentProviderConfig = NonNullable<Extract<GrantedSettlement, {
+    mode: "at_end";
+}>["paymentProvider"]>;
 declare global {
     interface Window {
         Stripe?: StripeConstructor;
@@ -62,8 +69,8 @@ export declare function deriveStripeCardStyle(root: HTMLElement): StripeElementS
  *
  * `null` means no usable Stripe client configuration reached this view. On a checkout-capable arm
  * that has exactly one cause — the configuration read failed — because the processor discriminator
- * is the `processor` field (reserved) or `checkoutMode` (enterable), never the presence of this
- * block. The condition is transient and retryable.
+ * is the settlement's `processor`/`mode` pair (granted) or `checkoutMode` (enterable), never the
+ * presence of this block. The condition is transient and retryable.
  */
 export declare function resolveStripeClientConfig(source: PaymentProviderConfig | undefined): StripeClientConfig | null;
 /** Test-only seam over every memo this module holds. Never exported from an adapter's public entry. */

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

@@ -3,9 +3,14 @@
  *
  * Shared granted composition for distribution modules. Renders the
  * winning-state panel: status badge, expiry countdown (or fallback message
- * when no expiry is known), and a checkout CTA. Used by queue / draw /
- * auction / timed-release modules — the JSX is structurally identical
- * across all four; only the i18n strings differ.
+ * when no expiry is known), and — only when the caller supplies a
+ * destination — a checkout CTA. Used by queue / draw / auction /
+ * timed-release modules — the JSX is structurally identical across all
+ * four; only the i18n strings differ.
+ *
+ * A granted frame with no `onCtaClick` renders no button: the grant is
+ * already settled where the consumer stands, so an inert affordance would
+ * promise a hand-off that does not exist.
  *
  *   <GrantedPanel
  *     label="Congratulations!"
@@ -24,9 +29,9 @@ import * as React from "react";
 export interface GrantedPanelProps {
     label: React.ReactNode;
     fallbackMessage: React.ReactNode;
-    ctaLabel: React.ReactNode;
+    ctaLabel?: React.ReactNode;
     expiresAt?: Date;
-    onCtaClick: () => void;
+    onCtaClick?: () => void;
     className?: string;
 }
 export declare function GrantedPanel({ label, fallbackMessage, ctaLabel, expiresAt, onCtaClick, className, }: GrantedPanelProps): import("react/jsx-runtime").JSX.Element;

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

@@ -10,6 +10,6 @@ export { JourneyGate, type JourneyGateProps, type JourneyGateStage } from './jou
 export { ChallengeGate, type ChallengeGateProps } from './challenge-gate';
 export { AccessCodeForm, type AccessCodeFormProps } from './access-code-form';
 export { GrantedPanel, type GrantedPanelProps } from './granted-panel';
-export { OutcomePanel, type OutcomePanelProps } from './outcome-panel';
+export { OutcomePanel, type OutcomeAction, type OutcomePanelProps } from './outcome-panel';
 export { EndedModule, type EndedModuleProps } from './ended-module';
 export { ErrorView, type ErrorViewProps } from './error-view';

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

@@ -4,6 +4,15 @@ import { OutcomeReason } from '../module';
  * (e.g. the expired re-enter button label) so each module shows terminology
  * appropriate to its mechanism rather than queue-specific copy.
  */
+/**
+ * A host-provided action for a terminal panel, such as "See what's still
+ * available" after a loss. The widget renders it as a secondary button; the
+ * host decides where it leads.
+ */
+export interface OutcomeAction {
+    label: string;
+    onClick: () => void;
+}
 export type ParticipationType = "queue" | "draw" | "auction" | "timed_release" | "appointment";
 export interface OutcomePanelProps {
     outcomeReason: OutcomeReason;
@@ -14,9 +23,11 @@ export interface OutcomePanelProps {
     participationType?: ParticipationType;
     onReenter?: () => Promise<void>;
     isReentering?: boolean;
+    /** Secondary action offered once the outcome is final. */
+    action?: OutcomeAction;
     className?: string;
 }
-export declare function OutcomePanel({ outcomeReason, participationType, onReenter, isReentering, className, }: OutcomePanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function OutcomePanel({ outcomeReason, participationType, onReenter, isReentering, action, className, }: OutcomePanelProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace OutcomePanel {
     var displayName: string;
 }

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

@@ -13,6 +13,8 @@ export { PanelHeading } from './panel-heading';
 export type { PanelHeadingProps, PanelHeadingVariant } from './panel-heading';
 export { InfoPanel } from './info-panel';
 export type { InfoPanelProps } from './info-panel';
+export { StageSteps } from './stage-steps';
+export type { StageStep, StageStepStatus, StageStepsProps } from './stage-steps';
 export { AlertPanel } from './alert-panel';
 export type { AlertPanelProps } from './alert-panel';
 export { normalizeOutcomeReason, normalizeSequenceOutcomeReason } from './outcome-reason';

package/dist/components/module/stage-steps.d.ts

@@ -0,0 +1,26 @@
+/**
+ * StageSteps
+ *
+ * A row of named stages for a phase whose end time is unknown. Completed
+ * stages read solid, the active stage pulses and its connector flows toward
+ * the next, and pending stages stay outlined. It communicates where the
+ * consumer is in a process without implying a percentage or a deadline.
+ *
+ *   <StageSteps
+ *     steps={[
+ *       { label: "You're in", status: "done" },
+ *       { label: "Drawing", status: "active" },
+ *       { label: "Results", status: "pending" },
+ *     ]}
+ *   />
+ */
+import * as React from "react";
+export type StageStepStatus = "done" | "active" | "pending";
+export interface StageStep {
+    label: string;
+    status: StageStepStatus;
+}
+export interface StageStepsProps extends React.HTMLAttributes<HTMLDivElement> {
+    steps: readonly StageStep[];
+}
+export declare const StageSteps: React.ForwardRefExoticComponent<StageStepsProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -1,7 +1,9 @@
 import { BotMitigationState, RoutingChallenge } from '@fanfare-io/fanfare-sdk-core/challenges';
-import { CheckoutNextAction, CheckoutProcessor, FanfareCheckoutResult, JourneyHandle, JourneySnapshot, JourneyView, PaymentInput, PaymentMethodSummary, ReservationPaymentAffordance, SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
+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, WidgetVariant } from '../../theme';
 import { AuthInputMode } from '../auth/auth-input';
+import { OutcomeAction } from '../compositions/outcome-panel';
 import * as React from "react";
 type ParticipationType = "queue" | "draw" | "auction" | "timed_release" | "appointment";
 type EnterableSlotSequence = Extract<SequenceView, {
@@ -15,6 +17,8 @@ type ParticipatingSlotSequence = Extract<SequenceView, {
 type GrantedSlotSequence = Extract<SequenceView, {
     phase: "granted";
 }>;
+/** How a granted win settles: who consumes the grant, and whether money has already moved for it. */
+type GrantedSettlement = GrantedSlotSequence["settlement"];
 /** Props passed to slot render functions */
 export interface SlotProps {
     snapshot: JourneySnapshot | null;
@@ -59,22 +63,17 @@ export interface GrantedSlotProps extends SlotProps {
     grant?: string;
     expiresAt?: number;
 }
-export interface PaymentCollectionSlotProps extends SlotProps {
-    preAuthAmount: string;
-    preAuthCurrencyCode: string;
+interface PaymentCollectionBaseSlotProps extends SlotProps {
     savedPaymentMethods: PaymentMethodSummary[];
-    /** Rejects on a recoverable payment failure (e.g. a declined card) — the panel owns recovery UI for its own submit. */
+    /** Submits pre-auth entry or confirms at-end checkout; rejects when the panel should keep recovery UI mounted. */
     onEnter: (paymentInput: PaymentInput) => Promise<void>;
     isEntering: boolean;
-    /** "enter" collects payment before first entry; "reenter" collects payment to retry after a failed or expired authorization hold. */
-    intent: "enter" | "reenter";
     /**
-     * Client configuration for the processor authorizing this entry, as the server supplied it.
-     * Carried by the enterable arm only — a retry is offered from an ended view, which holds no
-     * configuration.
+     * Client configuration for the internal processor, as the server supplied it. Carried by the
+     * enterable pre-auth and granted at-end arms; an ended retry holds no configuration.
      */
     paymentProvider?: PaymentProviderConfig;
-    /** Present while the processor is waiting on an out-of-band action; re-submitting entry resolves it. */
+    /** Present while the internal processor is waiting on an out-of-band action. */
     pendingAction?: CheckoutNextAction;
     /**
      * Re-reads the consumer's journeys from the server so a provider configuration that was missing
@@ -83,35 +82,22 @@ export interface PaymentCollectionSlotProps extends SlotProps {
      */
     onRetryPaymentConfig?: () => Promise<void>;
 }
+export type PaymentCollectionSlotProps = PaymentCollectionBaseSlotProps & ({
+    intent: "checkout";
+    onResume: () => Promise<void>;
+} | {
+    intent: "enter" | "reenter";
+    preAuthAmount: string;
+    preAuthCurrencyCode: string;
+    onResume?: never;
+});
 /**
- * The processor's client configuration block, named through the affordance that carries it: core
- * re-exports the affordance but not the contract's own name for this shape.
+ * The processor's client configuration block, named through an arm that carries it: core names the
+ * shape only within those arms, not as a standalone export.
  */
-type PaymentProviderConfig = NonNullable<ReservationPaymentAffordance["paymentProvider"]>;
-export interface ReservationCheckoutSlotProps extends SlotProps {
-    reservation: {
-        token: string;
-        expiresAt: number;
-    };
-    savedPaymentMethods: PaymentMethodSummary[];
-    /** Which processor executes this reservation's payment leg; narrow before rendering processor-specific UI. */
-    processor: CheckoutProcessor;
-    /** Client configuration for the processor settling this reservation, as the server supplied it. */
-    paymentProvider?: PaymentProviderConfig;
-    /** Present while the processor is waiting on an out-of-band action; complete it, then call `onResume`. */
-    pendingAction?: CheckoutNextAction;
-    /** Rejects on a recoverable payment failure (e.g. a declined card) — the panel owns recovery UI for its own submit. */
-    onConfirm: (paymentInput: PaymentInput) => Promise<void>;
-    /** Re-submits the paused checkout after `pendingAction` has been completed. Idempotent server-side. */
-    onResume: () => Promise<void>;
-    isConfirming: boolean;
-    /**
-     * Re-reads the consumer's journeys from the server so a provider configuration that was missing
-     * or unreadable at render can arrive. This is the panel's only recovery when `paymentProvider` is
-     * absent — the value is a prop, so nothing the panel does to its own state can produce it.
-     */
-    onRetryPaymentConfig?: () => Promise<void>;
-}
+type PaymentProviderConfig = NonNullable<Extract<GrantedSettlement, {
+    mode: "at_end";
+}>["paymentProvider"]>;
 export type CheckoutProcessingSlotProps = SlotProps;
 /**
  * A Fanfare-managed payment is terminal: it produces a receipt, never an admission credential. The
@@ -137,7 +123,8 @@ export interface EndedSlotProps extends SlotProps {
 }
 export interface ErrorSlotProps extends SlotProps {
     error: string;
-    onRetry: () => void;
+    /** Absent when the refusal cannot be cleared by retrying — render no retry affordance. */
+    onRetry?: () => void;
 }
 export interface LoadingSlotProps extends SlotProps {
     /** Stage-specific message (e.g. routing). `undefined` for generic loading — show just a spinner. */
@@ -162,13 +149,18 @@ export interface ExperienceWidgetSlots {
     participating?: (props: ParticipatingSlotProps) => React.ReactNode;
     granted?: (props: GrantedSlotProps) => React.ReactNode;
     paymentCollection?: (props: PaymentCollectionSlotProps) => React.ReactNode;
-    reservationCheckout?: (props: ReservationCheckoutSlotProps) => React.ReactNode;
+    /** Rendered by the at-end checkout surface while a collected payment is settling. */
     checkoutProcessing?: (props: CheckoutProcessingSlotProps) => React.ReactNode;
     receipt?: (props: ReceiptSlotProps) => React.ReactNode;
     expired?: (props: ExpiredSlotProps) => React.ReactNode;
     ended?: (props: EndedSlotProps) => React.ReactNode;
     error?: (props: ErrorSlotProps) => React.ReactNode;
 }
+/**
+ * Surface the widget is mounted on, named through the bus payload that carries it: core
+ * re-exports the event map but not the contract's own name for this shape.
+ */
+type BeaconPageType = SDKEvents["experience:widget-mounted"]["pageType"];
 /** Render props for full control */
 export interface ExperienceRenderProps {
     journey: JourneyHandle | null;
@@ -193,24 +185,32 @@ export interface ExperienceWidgetProps {
     variant?: WidgetVariant;
     /** Slots for targeted overrides */
     slots?: ExperienceWidgetSlots;
+    /**
+     * Surface this widget renders on, carried on the `experience:widget-mounted` announcement.
+     * Defaults to `embed`, the merchant-page case; Fanfare-hosted drop pages pass `hosted`.
+     */
+    pageType?: BeaconPageType;
     /** Render prop for full control (ignores slots if provided) */
     children?: (props: ExperienceRenderProps) => React.ReactNode;
     /** Checkout URL for granted state */
     checkoutUrl?: string;
+    /**
+     * Action offered on terminal panels (not selected, sold out, closed), such as
+     * a link back to what is still available. Omit to show none.
+     */
+    endedAction?: OutcomeAction;
     /** Called when journey state changes */
     onJourneyChange?: (snapshot: JourneySnapshot) => void;
     /** Called when the journey receives a grant */
     onGranted?: (grant: string) => void;
-    /** Called when a Fanfare-managed checkout completes (pre-auth capture or post-win reservation checkout) */
+    /** Called when a Fanfare-managed checkout completes */
     onFanfareCheckout?: (result: FanfareCheckoutResult) => void;
-    /** Called when the consumer wins a `post_win` distribution and must complete checkout before `expiresAt` */
-    onReserved?: (expiresAt: number) => void;
     /** Called when an error occurs */
     onError?: (error: Error) => void;
     /** Additional class name */
     className?: string;
 }
-export declare function ExperienceWidget({ experienceId, autoStart, accessCode, autoEnterWaitlist, theme, variant, slots, children, checkoutUrl, onJourneyChange, onGranted, onFanfareCheckout, onReserved, onError, className, }: ExperienceWidgetProps): import("react/jsx-runtime").JSX.Element;
+export declare function ExperienceWidget({ experienceId, autoStart, accessCode, autoEnterWaitlist, theme, variant, slots, pageType, children, checkoutUrl, endedAction, onJourneyChange, onGranted, onFanfareCheckout, onError, className, }: ExperienceWidgetProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace ExperienceWidget {
     var displayName: string;
 }

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

@@ -1,5 +1,6 @@
 import { AuctionDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
 import { ReadableAtom } from 'nanostores';
+import { OutcomeAction } from '../../compositions/outcome-panel';
 import { OutcomeReason } from '../../module';
 export interface AuctionModuleProps {
     display$?: ReadableAtom<AuctionDisplayState>;
@@ -23,11 +24,13 @@ export interface AuctionModuleProps {
     checkoutUrl?: string;
     onCheckoutClick?: () => void;
     outcomeReason?: OutcomeReason;
+    /** Host-provided action shown on the terminal panel. */
+    outcomeAction?: OutcomeAction;
     onReenter?: () => Promise<void>;
     isReentering?: boolean;
     className?: string;
 }
-export declare function AuctionModule({ display$, fallbackState, sequencePhase, canEnter, canLeave, onEnter, onLeave, onBid, isEntering, isLeaving, countdownTo, defaultBidAmount, currencyCode, locale, grant: _grant, expiresAt, checkoutUrl, onCheckoutClick, outcomeReason, onReenter, isReentering, className, }: AuctionModuleProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AuctionModule({ display$, fallbackState, sequencePhase, canEnter, canLeave, onEnter, onLeave, onBid, isEntering, isLeaving, countdownTo, defaultBidAmount, currencyCode, locale, grant: _grant, expiresAt, checkoutUrl, onCheckoutClick, outcomeReason, outcomeAction, onReenter, isReentering, className, }: AuctionModuleProps): import("react/jsx-runtime").JSX.Element | null;
 export declare namespace AuctionModule {
     var displayName: string;
 }

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

@@ -1,5 +1,6 @@
 import { DrawDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
 import { ReadableAtom } from 'nanostores';
+import { OutcomeAction } from '../../compositions/outcome-panel';
 import { OutcomeReason } from '../../module';
 export interface DrawModuleProps {
     /** Reactive display state atom from the journey */
@@ -30,6 +31,8 @@ export interface DrawModuleProps {
     onCheckoutClick?: () => void;
     /** Denial reason (denied) */
     outcomeReason?: OutcomeReason;
+    /** Host-provided action shown on the terminal panel. */
+    outcomeAction?: OutcomeAction;
     /** Re-enter handler (denied with reason="expired") */
     onReenter?: () => Promise<void>;
     /** Whether re-entering is in progress */
@@ -37,7 +40,7 @@ export interface DrawModuleProps {
     /** Additional class name */
     className?: string;
 }
-export declare function DrawModule({ display$, sequencePhase, canEnter, canLeave, onEnter, onLeave, isEntering, isLeaving, countdownTo, grant: _grant, expiresAt, checkoutUrl, onCheckoutClick, outcomeReason, onReenter, isReentering, className, }: DrawModuleProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DrawModule({ display$, sequencePhase, canEnter, canLeave, onEnter, onLeave, isEntering, isLeaving, countdownTo, grant: _grant, expiresAt, checkoutUrl, onCheckoutClick, outcomeReason, outcomeAction, onReenter, isReentering, className, }: DrawModuleProps): import("react/jsx-runtime").JSX.Element | null;
 export declare namespace DrawModule {
     var displayName: string;
 }

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

@@ -1,5 +1,6 @@
 import { QueueDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
 import { ReadableAtom } from 'nanostores';
+import { OutcomeAction } from '../../compositions/outcome-panel';
 import { OutcomeReason } from '../../module';
 export interface QueueModuleProps {
     display$?: ReadableAtom<QueueDisplayState>;
@@ -17,11 +18,13 @@ export interface QueueModuleProps {
     checkoutUrl?: string;
     onCheckoutClick?: () => void;
     outcomeReason?: OutcomeReason;
+    /** Host-provided action shown on the terminal panel. */
+    outcomeAction?: OutcomeAction;
     onReenter?: () => Promise<void>;
     isReentering?: boolean;
     className?: string;
 }
-export declare function QueueModule({ display$, sequencePhase, canEnter, canLeave, onEnter, onLeave, isEntering, isLeaving, closeAt, grant: _grant, expiresAt, checkoutUrl, onCheckoutClick, outcomeReason, onReenter, isReentering, className, }: QueueModuleProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function QueueModule({ display$, sequencePhase, canEnter, canLeave, onEnter, onLeave, isEntering, isLeaving, closeAt, grant: _grant, expiresAt, checkoutUrl, onCheckoutClick, outcomeReason, outcomeAction, onReenter, isReentering, className, }: QueueModuleProps): import("react/jsx-runtime").JSX.Element | null;
 export declare namespace QueueModule {
     var displayName: string;
 }

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

@@ -1,5 +1,6 @@
 import { TimedReleaseDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
 import { ReadableAtom } from 'nanostores';
+import { OutcomeAction } from '../../compositions/outcome-panel';
 import { OutcomeReason } from '../../module';
 export interface TimedReleaseModuleProps {
     display$?: ReadableAtom<TimedReleaseDisplayState>;
@@ -17,11 +18,13 @@ export interface TimedReleaseModuleProps {
     grant?: string;
     expiresAt?: number | Date;
     outcomeReason?: OutcomeReason;
+    /** Host-provided action shown on the terminal panel. */
+    outcomeAction?: OutcomeAction;
     onReenter?: () => Promise<void>;
     isReentering?: boolean;
     className?: string;
 }
-export declare function TimedReleaseModule({ display$, sequencePhase, canEnter, canLeave, onEnter, onLeave, onComplete, isEntering, isLeaving, countdownTo, checkoutUrl, onCheckoutClick, grant: _grant, expiresAt, outcomeReason, onReenter, isReentering, className, }: TimedReleaseModuleProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function TimedReleaseModule({ display$, sequencePhase, canEnter, canLeave, onEnter, onLeave, onComplete, isEntering, isLeaving, countdownTo, checkoutUrl, onCheckoutClick, grant: _grant, expiresAt, outcomeReason, outcomeAction, onReenter, isReentering, className, }: TimedReleaseModuleProps): import("react/jsx-runtime").JSX.Element | null;
 export declare namespace TimedReleaseModule {
     var displayName: string;
 }