@fanfare-io/fanfare-sdk-solid 0.1.0

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

@@ -0,0 +1,27 @@
+import { DrawDisplayState } from '@fanfare-io/fanfare-sdk-core/internals';
+import { ReadableAtom } from 'nanostores';
+import { OutcomeReason } from '../module';
+export interface DrawModuleProps {
+    state$?: ReadableAtom<DrawDisplayState>;
+    sequencePhase: "enterable" | "participating" | "settling" | "granted" | "ended";
+    canEnter: boolean;
+    canLeave: boolean;
+    onEnter: () => Promise<void>;
+    onLeave: () => Promise<void>;
+    isEntering: boolean;
+    isLeaving: boolean;
+    countdownTo?: Date;
+    grant?: string;
+    expiresAt?: number | Date;
+    checkoutUrl?: string;
+    onCheckoutClick?: () => void;
+    outcomeReason?: OutcomeReason;
+    onReenter?: () => Promise<void>;
+    isReentering?: boolean;
+    class?: string;
+    className?: string;
+}
+export declare function DrawModule(props: DrawModuleProps): import("solid-js").JSX.Element;
+export declare namespace DrawModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Internal Widget Views
+ *
+ * These are internal components used by ExperienceWidget for stage rendering.
+ * Not exported publicly in the React package (but Solid may export for advanced usage).
+ */
+export { LoadingView, type LoadingViewProps } from './loading-view';
+export { StartView, type StartViewProps } from './start-view';
+export { WaitlistView, type WaitlistViewProps } from './waitlist-view';
+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';

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

@@ -0,0 +1,9 @@
+export interface LoadingViewProps {
+    message?: string;
+    class?: string;
+    className?: string;
+}
+export declare function LoadingView(props: LoadingViewProps): import("solid-js").JSX.Element;
+export declare namespace LoadingView {
+    var displayName: string;
+}

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

@@ -0,0 +1,28 @@
+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;
+    class?: string;
+    className?: string;
+}
+export declare function QueueModule(props: QueueModuleProps): import("solid-js").JSX.Element;
+export declare namespace QueueModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,19 @@
+import { JSX } from 'solid-js';
+import { PanelHeadingVariant } from '../module';
+export interface StartViewProps {
+    variant?: PanelHeadingVariant;
+    label?: JSX.Element;
+    title?: JSX.Element;
+    description?: JSX.Element;
+    countdownTo?: Date;
+    info?: JSX.Element;
+    ctaLabel?: JSX.Element;
+    onStart?: () => void;
+    isLoading?: boolean;
+    class?: string;
+    className?: string;
+}
+export declare function StartView(props: StartViewProps): JSX.Element;
+export declare namespace StartView {
+    var displayName: string;
+}

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

@@ -0,0 +1,28 @@
+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;
+    class?: string;
+    className?: string;
+}
+export declare function TimedReleaseModule(props: TimedReleaseModuleProps): import("solid-js").JSX.Element;
+export declare namespace TimedReleaseModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,15 @@
+export interface UpcomingModuleProps {
+    title?: string;
+    description?: string;
+    startsAt?: Date | number;
+    onCountdownComplete?: () => void;
+    canEnter?: boolean;
+    onEnter?: () => void;
+    isEntering?: boolean;
+    class?: string;
+    className?: string;
+}
+export declare function UpcomingModule(props: UpcomingModuleProps): import("solid-js").JSX.Element;
+export declare namespace UpcomingModule {
+    var displayName: string;
+}

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

@@ -0,0 +1,14 @@
+export interface WaitlistViewProps {
+    title?: string;
+    description?: string;
+    startsAt?: Date | number;
+    onCountdownComplete?: () => void;
+    onLeave?: () => void;
+    isLeaving?: boolean;
+    class?: string;
+    className?: string;
+}
+export declare function WaitlistView(props: WaitlistViewProps): import("solid-js").JSX.Element;
+export declare namespace WaitlistView {
+    var displayName: string;
+}

package/dist/components/module/alert-panel.d.ts

@@ -0,0 +1,17 @@
+import { VariantProps } from 'class-variance-authority';
+import { JSX } from 'solid-js';
+declare const containerVariants: (props?: ({
+    tone?: "success" | "danger" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface AlertPanelProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "title">, Omit<VariantProps<typeof containerVariants>, "tone"> {
+    tone?: "danger" | "success";
+    icon?: JSX.Element;
+    title?: JSX.Element;
+    description?: JSX.Element;
+    className?: string;
+}
+export declare function AlertPanel(props: AlertPanelProps): JSX.Element;
+export declare namespace AlertPanel {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,5 @@
+export { AlertPanel, type AlertPanelProps } from './alert-panel';
+export { InfoPanel, type InfoPanelProps } from './info-panel';
+export { normalizeOutcomeReason, type OutcomeReason } from './outcome-reason';
+export { PanelHeading, type PanelHeadingProps, type PanelHeadingVariant } from './panel-heading';
+export { PanelBody, PanelFooter, PanelLayout, type PanelBodyProps, type PanelFooterProps, type PanelLayoutProps, } from './panel-layout';

package/dist/components/module/info-panel.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+export type InfoPanelProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function InfoPanel(props: InfoPanelProps): JSX.Element;
+export declare namespace InfoPanel {
+    var displayName: string;
+}

package/dist/components/module/outcome-reason.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Outcome-reason taxonomy (UI-facing)
+ *
+ * Distribution modules render an outcome state when a user can't proceed —
+ * because the admission grant expired, they weren't selected, the window
+ * closed, etc. This union is the *module-facing* taxonomy, narrower than
+ * the freeform strings the journey machine emits.
+ *
+ * `normalizeOutcomeReason` maps every known machine code (and any
+ * already-normalized UI value) to a member of the union. Unknown values
+ * fall back to `"ended"`.
+ *
+ *   journey machine code  ->  UI outcome reason
+ *   ----------------------------------------------
+ *   expired               ->  expired
+ *   queue_denied          ->  not_selected
+ *   draw_denied           ->  not_selected
+ *   timed_release_denied  ->  sold_out
+ *   already_completed     ->  ended
+ *   closed                ->  ended
+ *   unknown / other       ->  ended
+ *
+ * Static story lanes pass UI values directly (e.g. `"outbid"`); those
+ * pass through unchanged.
+ */
+export type OutcomeReason = "expired" | "not_selected" | "sold_out" | "outbid" | "reserve_not_met" | "ended";
+export declare function normalizeOutcomeReason(reason: string | undefined): OutcomeReason;

package/dist/components/module/panel-heading.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from 'solid-js';
+export type PanelHeadingVariant = "default" | "secondary" | "success" | "warning" | "danger" | "outline";
+export type PanelHeadingProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "title"> & {
+    variant?: PanelHeadingVariant;
+    label?: JSX.Element;
+    title?: JSX.Element;
+    description?: JSX.Element;
+    className?: string;
+};
+export declare function PanelHeading(props: PanelHeadingProps): JSX.Element;
+export declare namespace PanelHeading {
+    var displayName: string;
+}

package/dist/components/module/panel-layout.d.ts

@@ -0,0 +1,21 @@
+import { JSX } from 'solid-js';
+import { CardProps } from '../primitives/card';
+export type PanelBodyProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function PanelBody(props: PanelBodyProps): JSX.Element;
+export declare namespace PanelBody {
+    var displayName: string;
+}
+export type PanelFooterProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function PanelFooter(props: PanelFooterProps): JSX.Element;
+export declare namespace PanelFooter {
+    var displayName: string;
+}
+export type PanelLayoutProps = CardProps;
+export declare function PanelLayout(props: PanelLayoutProps): JSX.Element;
+export declare namespace PanelLayout {
+    var displayName: string;
+}

package/dist/components/primitives/badge.d.ts

@@ -0,0 +1,17 @@
+import { VariantProps } from 'class-variance-authority';
+import { JSX } from 'solid-js';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "success" | "warning" | "danger" | "outline" | null | undefined;
+    solid?: boolean | null | undefined;
+    styleVariant?: "default" | "retro" | "rounded" | "clean" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type BadgeVariant = "default" | "secondary" | "success" | "warning" | "danger" | "outline";
+export interface BadgeProps extends Omit<JSX.HTMLAttributes<HTMLSpanElement>, "color">, Omit<VariantProps<typeof badgeVariants>, "solid" | "styleVariant"> {
+    solidBackground?: boolean;
+    className?: string;
+}
+export declare function Badge(props: BadgeProps): JSX.Element;
+export declare namespace Badge {
+    var displayName: string;
+}
+export { badgeVariants };

package/dist/components/primitives/button.d.ts

@@ -0,0 +1,16 @@
+import { VariantProps } from 'class-variance-authority';
+import { JSX } from 'solid-js';
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "secondary" | "link" | "outline" | "ghost" | "destructive" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+    styleVariant?: "default" | "retro" | "rounded" | "clean" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement>, Omit<VariantProps<typeof buttonVariants>, "styleVariant"> {
+    loading?: boolean;
+    className?: string;
+}
+export declare function Button(props: ButtonProps): JSX.Element;
+export declare namespace Button {
+    var displayName: string;
+}
+export { buttonVariants };

package/dist/components/primitives/card.d.ts

@@ -0,0 +1,49 @@
+import { VariantProps } from 'class-variance-authority';
+import { JSX } from 'solid-js';
+declare const cardVariants: (props?: ({
+    variant?: "default" | "outlined" | "elevated" | null | undefined;
+    styleVariant?: "default" | "retro" | "rounded" | "clean" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface CardProps extends JSX.HTMLAttributes<HTMLDivElement>, Omit<VariantProps<typeof cardVariants>, "styleVariant"> {
+    className?: string;
+}
+export declare function Card(props: CardProps): JSX.Element;
+export declare namespace Card {
+    var displayName: string;
+}
+export { cardVariants };
+export type CardHeaderProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function CardHeader(props: CardHeaderProps): JSX.Element;
+export declare namespace CardHeader {
+    var displayName: string;
+}
+export type CardTitleProps = JSX.HTMLAttributes<HTMLHeadingElement> & {
+    className?: string;
+};
+export declare function CardTitle(props: CardTitleProps): JSX.Element;
+export declare namespace CardTitle {
+    var displayName: string;
+}
+export type CardDescriptionProps = JSX.HTMLAttributes<HTMLParagraphElement> & {
+    className?: string;
+};
+export declare function CardDescription(props: CardDescriptionProps): JSX.Element;
+export declare namespace CardDescription {
+    var displayName: string;
+}
+export type CardContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function CardContent(props: CardContentProps): JSX.Element;
+export declare namespace CardContent {
+    var displayName: string;
+}
+export type CardFooterProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function CardFooter(props: CardFooterProps): JSX.Element;
+export declare namespace CardFooter {
+    var displayName: string;
+}

package/dist/components/primitives/countdown.d.ts

@@ -0,0 +1,16 @@
+export interface CountdownProps {
+    targetDate: Date | string | number;
+    onComplete?: () => void;
+    expiredLabel?: string;
+    class?: string;
+    className?: string;
+    showDays?: boolean;
+    showHours?: boolean;
+    showMinutes?: boolean;
+    showSeconds?: boolean;
+    layout?: "swiss" | "compact";
+}
+export declare function Countdown(props: CountdownProps): import("solid-js").JSX.Element;
+export declare namespace Countdown {
+    var displayName: string;
+}

package/dist/components/primitives/fade-presence.d.ts

@@ -0,0 +1,11 @@
+import { JSX } from 'solid-js';
+export interface FadePresenceProps {
+    show: boolean;
+    children?: JSX.Element;
+    class?: string;
+    className?: string;
+}
+export declare function FadePresence(props: FadePresenceProps): JSX.Element;
+export declare namespace FadePresence {
+    var displayName: string;
+}

package/dist/components/primitives/fanfare-logo.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+export interface FanfareLogoProps extends JSX.SvgSVGAttributes<SVGSVGElement> {
+    className?: string;
+}
+export declare function FanfareLogo(props: FanfareLogoProps): JSX.Element;
+export declare namespace FanfareLogo {
+    var displayName: string;
+}

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

@@ -0,0 +1,11 @@
+export { Badge, badgeVariants, type BadgeProps, type BadgeVariant } from './badge';
+export { Button, buttonVariants, type ButtonProps } from './button';
+export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, cardVariants, type CardContentProps, type CardDescriptionProps, type CardFooterProps, type CardHeaderProps, type CardProps, type CardTitleProps, } from './card';
+export { Countdown, type CountdownProps } from './countdown';
+export { FadePresence, type FadePresenceProps } from './fade-presence';
+export { FanfareLogo, type FanfareLogoProps } from './fanfare-logo';
+export { Input, type InputProps } from './input';
+export { Progress, type ProgressProps } from './progress';
+export { Skeleton, type SkeletonProps } from './skeleton';
+export { Spinner, spinnerVariants, type SpinnerProps } from './spinner';
+export { Transition, type TransitionMode, type TransitionProps } from './transition';

package/dist/components/primitives/input.d.ts

@@ -0,0 +1,18 @@
+import { JSX } from 'solid-js';
+export interface InputProps extends JSX.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    error?: string;
+    /**
+     * Visual error state without inline text. Use when the message is rendered
+     * elsewhere (e.g. an AlertPanel under the input) but the field should still
+     * show its red border / invalid styling.
+     */
+    hasError?: boolean;
+    inlineLabel?: boolean;
+    inlineError?: boolean;
+    className?: string;
+}
+export declare function Input(props: InputProps): JSX.Element;
+export declare namespace Input {
+    var displayName: string;
+}

package/dist/components/primitives/progress.d.ts

@@ -0,0 +1,11 @@
+import { JSX } from 'solid-js';
+export interface ProgressProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+    showLabel?: boolean;
+    className?: string;
+}
+export declare function Progress(props: ProgressProps): JSX.Element;
+export declare namespace Progress {
+    var displayName: string;
+}

package/dist/components/primitives/skeleton.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+export type SkeletonProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    className?: string;
+};
+export declare function Skeleton(props: SkeletonProps): JSX.Element;
+export declare namespace Skeleton {
+    var displayName: string;
+}

package/dist/components/primitives/spinner.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import { JSX } from 'solid-js';
+declare const spinnerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    styleVariant?: "default" | "retro" | "rounded" | "clean" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SpinnerProps extends JSX.SvgSVGAttributes<SVGSVGElement>, Omit<VariantProps<typeof spinnerVariants>, "styleVariant"> {
+    className?: string;
+}
+export declare function Spinner(props: SpinnerProps): JSX.Element;
+export declare namespace Spinner {
+    var displayName: string;
+}
+export { spinnerVariants };

package/dist/components/primitives/transition.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from 'solid-js';
+export type TransitionMode = "fade" | "slide" | "scale" | "none";
+export interface TransitionProps {
+    children: JSX.Element;
+    transitionKey: string | number;
+    mode?: TransitionMode;
+    layout?: boolean;
+    className?: string;
+}
+export declare function Transition(props: TransitionProps): JSX.Element;
+export declare namespace Transition {
+    var displayName: string;
+}

package/dist/components/provider.d.ts

@@ -0,0 +1,27 @@
+import { FanfareSDK } from '@fanfare-io/fanfare-sdk-core';
+import { Locale, PartialTranslationMessages, TranslationMessageKey } from '@fanfare-io/fanfare-sdk-i18n';
+import { JSX } from 'solid-js';
+interface FanfareProviderProps {
+    sdk: FanfareSDK;
+    locale?: Locale;
+    translations?: PartialTranslationMessages<TranslationMessageKey>;
+    children: JSX.Element;
+}
+/**
+ * Fanfare provider for SolidJS apps
+ *
+ * @example
+ * ```tsx
+ * const sdk = await Fanfare.init({ ... });
+ *
+ * <FanfareProvider sdk={sdk}>
+ *   <App />
+ * </FanfareProvider>
+ * ```
+ */
+export declare function FanfareProvider(props: FanfareProviderProps): JSX.Element;
+/**
+ * Hook to access Fanfare SDK in SolidJS
+ */
+export declare function useFanfare(): FanfareSDK;
+export {};

package/dist/components/web/fanfare-web-component-provider.d.ts

@@ -0,0 +1,20 @@
+import { FanfareConfig } from '@fanfare-io/fanfare-sdk-core';
+import { BrandTheme, WidgetVariant } from '@fanfare-io/fanfare-sdk-core/theme';
+import { Locale, PartialTranslationMessages, TranslationMessageKey } from '@fanfare-io/fanfare-sdk-i18n';
+import { JSX } from 'solid-js';
+export interface FanfareWebComponentProviderProps {
+    config: FanfareConfig | null;
+    disabledReason?: string | null;
+    autoRestore?: boolean;
+    autoResume?: boolean;
+    locale?: Locale;
+    translations?: PartialTranslationMessages<TranslationMessageKey>;
+    themeConfig?: BrandTheme | null;
+    variant?: WidgetVariant;
+    className?: string;
+    children: JSX.Element;
+}
+export declare function FanfareWebComponentProvider(props: FanfareWebComponentProviderProps): JSX.Element;
+export declare namespace FanfareWebComponentProvider {
+    var displayName: string;
+}

package/dist/components/web/web-component-styles.d.ts

@@ -0,0 +1,4 @@
+export declare function WebComponentStyles(): import("solid-js").JSX.Element;
+export declare namespace WebComponentStyles {
+    var displayName: string;
+}

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

@@ -0,0 +1,21 @@
+export type AuctionStatus = "open" | "bidding" | "winning" | "outbid" | "won" | "lost" | "ended";
+export interface AuctionActionsProps {
+    status: AuctionStatus;
+    currentBid: number;
+    minNextBid: number;
+    bidIncrement: number;
+    onBid?: (amount: number) => void;
+    onProceed?: () => void;
+    isBidding?: boolean;
+    bidLabel?: string;
+    proceedLabel?: string;
+    currencyCode?: string;
+    locale?: string;
+    showQuickBids?: boolean;
+    class?: string;
+    className?: string;
+}
+export declare function AuctionActions(props: AuctionActionsProps): import("solid-js").JSX.Element;
+export declare namespace AuctionActions {
+    var displayName: string;
+}

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

@@ -0,0 +1,19 @@
+export interface AuctionBidDisplayProps {
+    currentBid: number;
+    myBid?: number | null;
+    minNextBid: number;
+    bidIncrement: number;
+    reservePrice?: number;
+    reserveMet?: boolean;
+    bidCount?: number;
+    isWinning?: boolean;
+    currencyCode?: string;
+    locale?: string;
+    size?: "sm" | "md" | "lg";
+    class?: string;
+    className?: string;
+}
+export declare function AuctionBidDisplay(props: AuctionBidDisplayProps): import("solid-js").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,22 @@
+export type DrawStatus = "open" | "entered" | "drawing" | "won" | "lost" | "ended";
+export interface DrawActionsProps {
+    status: DrawStatus;
+    onEnter?: () => void;
+    onWithdraw?: () => void;
+    onShare?: () => void;
+    onProceed?: () => void;
+    isEntering?: boolean;
+    isWithdrawing?: boolean;
+    enterLabel?: string;
+    withdrawLabel?: string;
+    shareLabel?: string;
+    proceedLabel?: string;
+    showShare?: boolean;
+    layout?: "horizontal" | "vertical";
+    class?: string;
+    className?: string;
+}
+export declare function DrawActions(props: DrawActionsProps): import("solid-js").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';