@fanfare-io/fanfare-sdk-react 0.1.0

package/dist/components/widgets/appointment/appointment-day-tabs.d.ts

@@ -0,0 +1,21 @@
+export interface AppointmentDayTabsProps {
+    days: AppointmentDay[];
+    selectedDate: string | null;
+    onSelect(date: string): void;
+}
+export interface AppointmentDay {
+    /** ISO date string (YYYY-MM-DD) used as the stable key and selection value. */
+    date: string;
+    /** Short weekday label like "Mon". */
+    weekdayLabel: string;
+    /** Day-of-month number for the large label. */
+    dayNumber: number;
+    /** Whether any slots are available on this day. */
+    hasAvailability: boolean;
+    /** Whether the location is closed entirely on this day (no slots generated at all). */
+    isClosed: boolean;
+}
+export declare function AppointmentDayTabs({ days, selectedDate, onSelect }: AppointmentDayTabsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppointmentDayTabs {
+    var displayName: string;
+}

package/dist/components/widgets/appointment/appointment-slot-grid.d.ts

@@ -0,0 +1,12 @@
+import { AppointmentSlot } from '@fanfare-io/fanfare-sdk-core/appointments';
+export interface AppointmentSlotGridProps {
+    slots: AppointmentSlot[];
+    isLoading: boolean;
+    selectedSlotId: string | null;
+    onSelect(slotId: string): void;
+    emptyMessage?: string;
+}
+export declare function AppointmentSlotGrid({ slots, isLoading, selectedSlotId, onSelect, emptyMessage, }: AppointmentSlotGridProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppointmentSlotGrid {
+    var displayName: string;
+}

package/dist/components/widgets/appointment/appointment-slot-item.d.ts

@@ -0,0 +1,12 @@
+export interface AppointmentSlotItemProps {
+    slotId: string;
+    timeLabel: string;
+    ariaLabel: string;
+    isFull: boolean;
+    isSelected: boolean;
+    onSelect(slotId: string): void;
+}
+export declare function AppointmentSlotItem({ slotId, timeLabel, ariaLabel, isFull, isSelected, onSelect, }: AppointmentSlotItemProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppointmentSlotItem {
+    var displayName: string;
+}

package/dist/components/widgets/appointment/appointment-slot-picker.d.ts

@@ -0,0 +1,16 @@
+import { AppointmentSlot } from '@fanfare-io/fanfare-sdk-core/appointments';
+export interface AppointmentSlotPickerProps {
+    appointmentId: string;
+    /** Defaults to today, clipped to the open window. */
+    bookingWindowOpenAt?: string;
+    bookingWindowCloseAt?: string;
+    timezone?: string;
+    /** Bubbled up so the parent can drive the confirm button label / enabled state. */
+    onSlotChange?(slot: AppointmentSlot | null): void;
+    /** Error from the parent's book action — surfaced inline beneath the grid. */
+    bookError?: string | null;
+}
+export declare function AppointmentSlotPicker({ appointmentId, bookingWindowOpenAt, bookingWindowCloseAt, timezone, onSlotChange, bookError, }: AppointmentSlotPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppointmentSlotPicker {
+    var displayName: string;
+}

package/dist/components/widgets/auction/auction-actions.d.ts

@@ -0,0 +1,38 @@
+/**
+ * AuctionActions Component
+ *
+ * Bid form and action buttons for auction operations.
+ */
+export type AuctionStatus = "open" | "bidding" | "winning" | "outbid" | "won" | "lost" | "ended";
+export interface AuctionActionsProps {
+    /** Current auction status */
+    status: AuctionStatus;
+    /** Current highest bid */
+    currentBid: number;
+    /** Minimum next bid */
+    minNextBid: number;
+    /** Bid increment */
+    bidIncrement: number;
+    /** Place bid handler */
+    onBid?: (amount: number) => void;
+    /** Proceed to checkout handler (for won status) */
+    onProceed?: () => void;
+    /** Whether bid is in progress */
+    isBidding?: boolean;
+    /** Bid button label */
+    bidLabel?: string;
+    /** Proceed button label */
+    proceedLabel?: string;
+    /** Currency code (ISO 4217). */
+    currencyCode?: string;
+    /** Locale used for formatting */
+    locale?: string;
+    /** Show quick bid buttons */
+    showQuickBids?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+export declare function AuctionActions({ status, currentBid, minNextBid, bidIncrement, onBid, onProceed, isBidding, bidLabel, proceedLabel, currencyCode, locale, showQuickBids, className, }: AuctionActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AuctionActions {
+    var displayName: string;
+}

package/dist/components/widgets/auction/auction-bid-display.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AuctionBidDisplay Component
+ *
+ * Displays the current bid amount and auction status.
+ */
+export interface AuctionBidDisplayProps {
+    /** Current highest bid */
+    currentBid: number;
+    /** User's bid (if any) */
+    myBid?: number | null;
+    /** Minimum next bid */
+    minNextBid: number;
+    /** Bid increment */
+    bidIncrement: number;
+    /** Reserve price */
+    reservePrice?: number;
+    /** Whether reserve is met */
+    reserveMet?: boolean;
+    /** Total number of bids */
+    bidCount?: number;
+    /** Whether the user is winning */
+    isWinning?: boolean;
+    /** Currency code (ISO 4217). */
+    currencyCode?: string;
+    /** Locale used for formatting */
+    locale?: string;
+    /** Visual size */
+    size?: "sm" | "md" | "lg";
+    /** Additional class name */
+    className?: string;
+}
+export declare function AuctionBidDisplay({ currentBid, myBid, minNextBid, bidIncrement, reservePrice, reserveMet, bidCount, isWinning, currencyCode, locale, size, className, }: AuctionBidDisplayProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AuctionBidDisplay {
+    var displayName: string;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Auction Widget Internal Components
+ *
+ * Building blocks for the AuctionWidget.
+ */
+export { AuctionActions, type AuctionActionsProps, type AuctionStatus } from './auction-actions';
+export { AuctionBidDisplay, type AuctionBidDisplayProps } from './auction-bid-display';

package/dist/components/widgets/draw/draw-actions.d.ts

@@ -0,0 +1,40 @@
+/**
+ * DrawActions Component
+ *
+ * Action buttons for draw operations (enter, withdraw, share).
+ */
+export type DrawStatus = "open" | "entered" | "drawing" | "won" | "lost" | "ended";
+export interface DrawActionsProps {
+    /** Current draw status */
+    status: DrawStatus;
+    /** Enter draw handler */
+    onEnter?: () => void;
+    /** Withdraw entry handler */
+    onWithdraw?: () => void;
+    /** Share entry handler */
+    onShare?: () => void;
+    /** Proceed to checkout handler (for won status) */
+    onProceed?: () => void;
+    /** Whether enter is in progress */
+    isEntering?: boolean;
+    /** Whether withdraw is in progress */
+    isWithdrawing?: boolean;
+    /** Enter button label */
+    enterLabel?: string;
+    /** Withdraw button label */
+    withdrawLabel?: string;
+    /** Share button label */
+    shareLabel?: string;
+    /** Proceed button label */
+    proceedLabel?: string;
+    /** Show share button */
+    showShare?: boolean;
+    /** Layout direction */
+    layout?: "horizontal" | "vertical";
+    /** Additional class name */
+    className?: string;
+}
+export declare function DrawActions({ status, onEnter, onWithdraw, onShare, onProceed, isEntering, isWithdrawing, enterLabel, withdrawLabel, shareLabel, proceedLabel, showShare, layout, className, }: DrawActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace DrawActions {
+    var displayName: string;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Draw Widget Internal Components
+ *
+ * Building blocks for the DrawWidget.
+ */
+export { DrawActions, type DrawActionsProps, type DrawStatus } from './draw-actions';

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

@@ -0,0 +1,141 @@
+import { BotMitigationState, RoutingChallenge } from '@fanfare-io/fanfare-sdk-core/challenges';
+import { JourneyHandle, JourneySnapshot, JourneyView, SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
+import { BrandTheme } from '../../theme';
+import { AuthInputMode } from '../auth/auth-input';
+import * as React from "react";
+type ParticipationType = "queue" | "draw" | "auction" | "timed_release" | "appointment";
+type EnterableSlotSequence = Extract<SequenceView, {
+    phase: "enterable";
+    mechanism: ParticipationType;
+}>;
+type ParticipatingSlotSequence = Extract<SequenceView, {
+    phase: "participating";
+    mechanism: ParticipationType;
+}>;
+type GrantedSlotSequence = Extract<SequenceView, {
+    phase: "granted";
+}>;
+/** Props passed to slot render functions */
+export interface SlotProps {
+    snapshot: JourneySnapshot | null;
+    view: JourneyView | null;
+    error: string | null;
+}
+export interface StartSlotProps extends SlotProps {
+    onStart: () => void;
+    isStarting: boolean;
+}
+export interface AuthSlotProps extends SlotProps {
+    onSubmit: (credential: string, type: AuthInputMode) => Promise<void>;
+    onVerify: (otp: string) => Promise<void>;
+    onSkip?: () => void;
+}
+export interface AccessCodeSlotProps extends SlotProps {
+    onSubmit: (code: string) => Promise<void>;
+    onSkip?: () => void;
+}
+export interface UpcomingSlotProps extends SlotProps {
+    startsAt?: Date;
+    canEnter: boolean;
+    onEnter: () => void;
+    isEntering: boolean;
+}
+export interface WaitlistSlotProps extends SlotProps {
+    startsAt?: Date;
+    onLeave: () => void;
+    isLeaving: boolean;
+}
+export interface EnterableSlotProps extends SlotProps {
+    sequence: EnterableSlotSequence;
+    participationType: ParticipationType;
+}
+export interface ParticipatingSlotProps extends SlotProps {
+    sequence: ParticipatingSlotSequence;
+    participationType: ParticipationType;
+    position?: number;
+}
+export interface GrantedSlotProps extends SlotProps {
+    sequence: GrantedSlotSequence;
+    grant?: string;
+    expiresAt?: number;
+}
+export interface ExpiredSlotProps extends SlotProps {
+    reason: string;
+    endedAt?: Date;
+}
+export interface EndedSlotProps extends SlotProps {
+    reason: string;
+    endedAt?: Date;
+}
+export interface ErrorSlotProps extends SlotProps {
+    error: string;
+    onRetry: () => void;
+}
+export interface LoadingSlotProps extends SlotProps {
+    /** Stage-specific message (e.g. routing). `undefined` for generic loading — show just a spinner. */
+    message?: string;
+}
+export interface ChallengeSlotProps extends SlotProps {
+    challenge: RoutingChallenge | null;
+    botMitigation?: BotMitigationState;
+    onVerifyToken: (token: string) => Promise<void>;
+    onRetry: () => void;
+}
+/** Slots for overriding specific views */
+export interface ExperienceWidgetSlots {
+    start?: (props: StartSlotProps) => React.ReactNode;
+    loading?: (props: LoadingSlotProps) => React.ReactNode;
+    auth?: (props: AuthSlotProps) => React.ReactNode;
+    accessCode?: (props: AccessCodeSlotProps) => React.ReactNode;
+    challenge?: (props: ChallengeSlotProps) => React.ReactNode;
+    upcoming?: (props: UpcomingSlotProps) => React.ReactNode;
+    waitlist?: (props: WaitlistSlotProps) => React.ReactNode;
+    enterable?: (props: EnterableSlotProps) => React.ReactNode;
+    participating?: (props: ParticipatingSlotProps) => React.ReactNode;
+    granted?: (props: GrantedSlotProps) => React.ReactNode;
+    expired?: (props: ExpiredSlotProps) => React.ReactNode;
+    ended?: (props: EndedSlotProps) => React.ReactNode;
+    error?: (props: ErrorSlotProps) => React.ReactNode;
+}
+/** Render props for full control */
+export interface ExperienceRenderProps {
+    journey: JourneyHandle | null;
+    view: JourneyView | null;
+    snapshot: JourneySnapshot | null;
+    error: string | null;
+    start: () => Promise<void>;
+    isStarting: boolean;
+}
+export interface ExperienceWidgetProps {
+    /** Experience ID to load */
+    experienceId: string;
+    /** Automatically start journey on mount */
+    autoStart?: boolean;
+    /** Pre-fill access code */
+    accessCode?: string;
+    /** Auto-enter waitlist when available */
+    autoEnterWaitlist?: boolean;
+    /** Theme customization */
+    theme?: BrandTheme;
+    /** Widget variant (overrides theme.variant if provided) */
+    variant?: "default" | "retro" | "rounded" | "clean";
+    /** Slots for targeted overrides */
+    slots?: ExperienceWidgetSlots;
+    /** Render prop for full control (ignores slots if provided) */
+    children?: (props: ExperienceRenderProps) => React.ReactNode;
+    /** Checkout URL for granted state */
+    checkoutUrl?: string;
+    /** Called when journey state changes */
+    onJourneyChange?: (snapshot: JourneySnapshot) => void;
+    /** Called when the journey receives a grant */
+    onGranted?: (grant: string) => 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, onError, className, }: ExperienceWidgetProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ExperienceWidget {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * Widget Components
+ *
+ * ExperienceWidget is the primary entry point for all distribution types.
+ * Standalone widgets are deprecated - use ExperienceWidget instead.
+ *
+ * @packageDocumentation
+ */
+export { ExperienceWidget, type AccessCodeSlotProps, type AuthSlotProps, type EndedSlotProps, type EnterableSlotProps, type ErrorSlotProps, type ExperienceRenderProps, type ExperienceWidgetProps, type ExperienceWidgetSlots, type ExpiredSlotProps, type GrantedSlotProps, type LoadingSlotProps, type ParticipatingSlotProps, 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 { AuctionModule, DrawModule, QueueModule, TimedReleaseModule, type AuctionModuleProps, type DrawModuleProps, type QueueModuleProps, type TimedReleaseModuleProps, } from './internal';

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

@@ -0,0 +1,28 @@
+import { AppointmentDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { ReadableAtom } from 'nanostores';
+import { OutcomeReason } from '../../module';
+export interface AppointmentModuleProps {
+    appointmentId: string;
+    state$?: ReadableAtom<AppointmentDisplayState>;
+    sequencePhase: "enterable" | "participating" | "ended";
+    bookingWindowOpenAt?: string;
+    bookingWindowCloseAt?: string;
+    timezone?: string;
+    defaultLocationId?: string;
+    onBook: (slotId: string, locationId?: string) => Promise<void>;
+    onCancel: (reason?: string) => Promise<void>;
+    onReschedule: (newSlotId: string, newLocationId?: string) => Promise<void>;
+    isBooking: boolean;
+    isCancelling: boolean;
+    isRescheduling: boolean;
+    bookError?: string | null;
+    cancelError?: string | null;
+    outcomeReason?: OutcomeReason;
+    onReenter?: () => Promise<void>;
+    isReentering?: boolean;
+    className?: string;
+}
+export declare function AppointmentModule({ appointmentId, state$, sequencePhase, bookingWindowOpenAt, bookingWindowCloseAt, timezone, defaultLocationId, onBook, onCancel, onReschedule, isBooking, isCancelling, isRescheduling, bookError, cancelError, outcomeReason, onReenter, isReentering, className, }: AppointmentModuleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppointmentModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,33 @@
+import { AuctionDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { ReadableAtom } from 'nanostores';
+import { OutcomeReason } from '../../module';
+export interface AuctionModuleProps {
+    state$?: ReadableAtom<AuctionDisplayState>;
+    fallbackState?: AuctionDisplayState;
+    sequencePhase: "enterable" | "participating" | "settling" | "granted" | "ended";
+    canEnter: boolean;
+    canLeave: boolean;
+    onEnter: () => Promise<void>;
+    onLeave: () => Promise<void>;
+    onBid?: (amount: string) => Promise<void>;
+    isEntering: boolean;
+    isLeaving: boolean;
+    countdownTo?: Date;
+    defaultBidAmount?: string;
+    /** Currency code for bid display (overridden by displayState.currencyCode if present) */
+    currencyCode?: string;
+    /** Locale for currency formatting */
+    locale?: string;
+    grant?: string;
+    expiresAt?: number | Date;
+    checkoutUrl?: string;
+    onCheckoutClick?: () => void;
+    outcomeReason?: OutcomeReason;
+    onReenter?: () => Promise<void>;
+    isReentering?: boolean;
+    className?: string;
+}
+export declare function AuctionModule({ state$, 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 namespace AuctionModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,43 @@
+import { DrawDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { ReadableAtom } from 'nanostores';
+import { OutcomeReason } from '../../module';
+export interface DrawModuleProps {
+    /** Reactive display state atom from the journey */
+    state$?: ReadableAtom<DrawDisplayState>;
+    /** Current sequence phase */
+    sequencePhase: "enterable" | "participating" | "settling" | "granted" | "ended";
+    /** Whether user can enter (active only) */
+    canEnter: boolean;
+    /** Whether user can leave (participating only) */
+    canLeave: boolean;
+    /** Enter action handler */
+    onEnter: () => Promise<void>;
+    /** Leave action handler */
+    onLeave: () => Promise<void>;
+    /** Whether entering is in progress */
+    isEntering: boolean;
+    /** Whether leaving is in progress */
+    isLeaving: boolean;
+    /** Draw time for countdown (active/participating) */
+    countdownTo?: Date;
+    /** Grant token */
+    grant?: string;
+    /** When grant expires */
+    expiresAt?: number | Date;
+    /** Checkout URL — opens in a new tab when CTA clicked (granted) */
+    checkoutUrl?: string;
+    /** Override checkout click handler (granted) */
+    onCheckoutClick?: () => void;
+    /** Denial reason (denied) */
+    outcomeReason?: OutcomeReason;
+    /** Re-enter handler (denied with reason="expired") */
+    onReenter?: () => Promise<void>;
+    /** Whether re-entering is in progress */
+    isReentering?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+export declare function DrawModule({ state$, 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 namespace DrawModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Internal Widget Views
+ *
+ * These are internal components used by ExperienceWidget for stage rendering.
+ * Not exported publicly - use slots to override these views.
+ */
+export { AppointmentModule, type AppointmentModuleProps } from './appointment-module';
+export { AuctionModule, type AuctionModuleProps } from './auction-module';
+export { DrawModule, type DrawModuleProps } from './draw-module';
+export { QueueModule, type QueueModuleProps } from './queue-module';
+export { TimedReleaseModule, type TimedReleaseModuleProps } from './timed-release-module';
+export { UpcomingModule, type UpcomingModuleProps } from './upcoming-module';
+export { LoadingView, type LoadingViewProps } from './loading-view';
+export { StartView, type StartViewProps } from './start-view';
+export { WaitlistView, type WaitlistViewProps } from './waitlist-view';

package/dist/components/widgets/internal/loading-view.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LoadingView Component
+ *
+ * Shown during journey stage transitions. Spinner with optional message.
+ * Deliberately NOT using PanelLayout — this is a transient hint, not a panel
+ * with branding/footer.
+ */
+export interface LoadingViewProps {
+    /** Loading message */
+    message?: string;
+    /** Additional class name */
+    className?: string;
+}
+export declare function LoadingView({ message, className }: LoadingViewProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace LoadingView {
+    var displayName: string;
+}

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

@@ -0,0 +1,27 @@
+import { QueueDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { ReadableAtom } from 'nanostores';
+import { OutcomeReason } from '../../module';
+export interface QueueModuleProps {
+    state$?: ReadableAtom<QueueDisplayState>;
+    sequencePhase: "enterable" | "participating" | "granted" | "ended";
+    canEnter: boolean;
+    canLeave: boolean;
+    onEnter: () => Promise<void>;
+    onLeave: () => Promise<void>;
+    isEntering: boolean;
+    isLeaving: boolean;
+    /** When the queue stops accepting entries — drives the "Queue closes in" countdown. */
+    closeAt?: Date;
+    grant?: string;
+    expiresAt?: number | Date;
+    checkoutUrl?: string;
+    onCheckoutClick?: () => void;
+    outcomeReason?: OutcomeReason;
+    onReenter?: () => Promise<void>;
+    isReentering?: boolean;
+    className?: string;
+}
+export declare function QueueModule({ state$, 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 namespace QueueModule {
+    var displayName: string;
+}

package/dist/components/widgets/internal/start-view.d.ts

@@ -0,0 +1,25 @@
+import { PanelHeadingVariant } from '../../module';
+/**
+ * StartView
+ *
+ * Pre-routing state — shown when `journeyStage === "ready"`. Renders a
+ * Get-Started panel with an optional countdown and an `info` slot. CTA
+ * triggers `journey.start()` via `onStart`.
+ */
+import * as React from "react";
+export interface StartViewProps {
+    variant?: PanelHeadingVariant;
+    label?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    countdownTo?: Date;
+    info?: React.ReactNode;
+    ctaLabel?: React.ReactNode;
+    onStart?: () => void;
+    isLoading?: boolean;
+    className?: string;
+}
+export declare function StartView({ variant, label, title, description, countdownTo, info, ctaLabel, onStart, isLoading, className, }: StartViewProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace StartView {
+    var displayName: string;
+}

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

@@ -0,0 +1,27 @@
+import { TimedReleaseDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { ReadableAtom } from 'nanostores';
+import { OutcomeReason } from '../../module';
+export interface TimedReleaseModuleProps {
+    state$?: ReadableAtom<TimedReleaseDisplayState>;
+    sequencePhase: "enterable" | "participating" | "granted" | "ended";
+    canEnter: boolean;
+    canLeave: boolean;
+    onEnter: () => Promise<void>;
+    onLeave: () => Promise<void>;
+    onComplete?: () => Promise<void>;
+    isEntering: boolean;
+    isLeaving: boolean;
+    countdownTo?: Date;
+    checkoutUrl?: string;
+    onCheckoutClick?: () => void;
+    grant?: string;
+    expiresAt?: number | Date;
+    outcomeReason?: OutcomeReason;
+    onReenter?: () => Promise<void>;
+    isReentering?: boolean;
+    className?: string;
+}
+export declare function TimedReleaseModule({ state$, 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 namespace TimedReleaseModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * UpcomingModule
+ *
+ * Shared (distribution-agnostic) module rendered before the active sequence
+ * begins. Honors the v3 anatomy contract — Badge + Countdown + optional
+ * CTA — composed from the shared kit.
+ */
+export interface UpcomingModuleProps {
+    /** Title text override */
+    title?: string;
+    /** Description text override */
+    description?: string;
+    /** When the distribution starts */
+    startsAt?: Date | number;
+    /** Called when countdown completes */
+    onCountdownComplete?: () => void;
+    /** Whether entry is available */
+    canEnter?: boolean;
+    /** Called when user enters */
+    onEnter?: () => void;
+    /** Whether entry is in progress */
+    isEntering?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+export declare function UpcomingModule({ title, description, startsAt, onCountdownComplete, canEnter, onEnter, isEntering, className, }: UpcomingModuleProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace UpcomingModule {
+    var displayName: string;
+}

package/dist/components/widgets/internal/waitlist-view.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WaitlistView Component
+ *
+ * Shown when user has joined the waitlist for an upcoming distribution.
+ */
+export interface WaitlistViewProps {
+    title?: string;
+    description?: string;
+    startsAt?: Date | number;
+    onCountdownComplete?: () => void;
+    onLeave?: () => void;
+    isLeaving?: boolean;
+    className?: string;
+}
+export declare function WaitlistView({ title, description, startsAt, onCountdownComplete, onLeave, isLeaving, className, }: WaitlistViewProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WaitlistView {
+    var displayName: string;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Queue Widget Internal Components
+ *
+ * Building blocks for the QueueWidget.
+ */
+export { QueueActions, type QueueActionsProps, type QueueStatus } from './queue-actions';