@founderhq/journeys 0.3.67 → 0.4.1

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,2300 @@
+import { Accordion as Accordion_2 } from 'radix-ui';
+import { Checkbox as Checkbox_2 } from 'radix-ui';
+import { ClassProp } from 'class-variance-authority/types';
+import { ClassValue } from 'clsx';
+import type { ComponentType } from 'react';
+import { Context } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { JSX } from 'react';
+import { RadioGroup as RadioGroup_2 } from 'radix-ui';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+import { RefAttributes } from 'react';
+import { Tooltip as Tooltip_2 } from 'radix-ui';
+import useEmblaCarousel from 'embla-carousel-react';
+import { UseEmblaCarouselType } from 'embla-carousel-react';
+import { VariantProps } from 'class-variance-authority';
+
+export declare function Accordion({ ...props }: React_2.ComponentProps<typeof Accordion_2.Root>): React_2.JSX.Element;
+
+export declare function AccordionBlock({ items, type, defaultOpen, className, }: AccordionBlockProps): JSX.Element;
+
+declare type AccordionBlockProps = {
+    items: AccordionItem[];
+    type?: "single" | "multiple";
+    defaultOpen?: number[];
+    className?: string;
+};
+export { AccordionBlockProps }
+export { AccordionBlockProps as AccordionBlockProps_alias_1 }
+
+export declare function AccordionContent({ className, children, ...props }: React_2.ComponentProps<typeof Accordion_2.Content>): React_2.JSX.Element;
+
+declare type AccordionItem = {
+    title: string;
+    content: string;
+};
+export { AccordionItem }
+export { AccordionItem as AccordionItem_alias_1 }
+
+export declare function AccordionItem_alias_2({ className, ...props }: React_2.ComponentProps<typeof Accordion_2.Item>): React_2.JSX.Element;
+
+export declare function AccordionTrigger({ className, children, ...props }: React_2.ComponentProps<typeof Accordion_2.Trigger>): React_2.JSX.Element;
+
+declare type AnimationPreset = "fade-in" | "slide-up" | "slide-down" | "slide-left" | "slide-right" | "scale-up" | "blur-in" | "none";
+export { AnimationPreset }
+export { AnimationPreset as AnimationPreset_alias_1 }
+
+declare type AppliedDiscountAnswer = {
+    code: string;
+    /** Plan id this discount was validated against. Omit for plan-agnostic offers. */
+    planId?: string;
+    planVariable?: string;
+    message?: string;
+    pricing?: AppliedDiscountPricing;
+    summaryLines?: DiscountCodeSummaryLine[];
+    metadata?: Record<string, unknown>;
+};
+export { AppliedDiscountAnswer }
+export { AppliedDiscountAnswer as AppliedDiscountAnswer_alias_1 }
+
+declare type AppliedDiscountPricing = {
+    /** Optional display override for the discounted plan price. When set, pricing_plans renders it verbatim. */
+    display?: string;
+    /** Optional numeric discounted amount for consumers that want Journeys to format the card price. */
+    amount?: number;
+    currency?: string;
+    period?: PricingPlanPeriod;
+    perUnitLabel?: string;
+    originalAmount?: number;
+    /** Generic presentation fields; values and units are consumer-owned. `total` is used as a card-price fallback. */
+    baseAmount?: number;
+    discountAmount?: number;
+    subtotal?: number;
+    taxAmount?: number;
+    total?: number;
+};
+export { AppliedDiscountPricing }
+export { AppliedDiscountPricing as AppliedDiscountPricing_alias_1 }
+
+declare type Arc = {
+    id: string;
+    label: string;
+    stepIds: string[];
+};
+export { Arc }
+export { Arc as Arc_alias_1 }
+
+/**
+ * Returns true when every input block on the page that contributes a required answer
+ * has a satisfying value in `answers`. Blocks whose `condition` evaluates false are
+ * skipped (they aren't visible, so they can't gate the next button).
+ */
+declare function arePageInputsValid(blocks: BlockConfig[], answers: JourneyAnswers): boolean;
+export { arePageInputsValid }
+export { arePageInputsValid as arePageInputsValid_alias_1 }
+
+export declare function AvatarBlock({ src, name, size, borderColor, borderWidth, className, }: AvatarBlockProps): JSX.Element;
+
+export declare type AvatarBlockProps = {
+    src?: string;
+    name?: string;
+    size?: number;
+    borderColor?: string;
+    borderWidth?: number;
+    className?: string;
+};
+
+export declare function AvatarGroupBlock({ avatars, size, overlap, max, borderColor, borderWidth, className, }: AvatarGroupBlockProps): JSX.Element;
+
+declare type AvatarGroupBlockProps = {
+    avatars: AvatarItem[];
+    size?: number;
+    overlap?: number;
+    max?: number;
+    borderColor?: string;
+    borderWidth?: number;
+    className?: string;
+};
+export { AvatarGroupBlockProps }
+export { AvatarGroupBlockProps as AvatarGroupBlockProps_alias_1 }
+
+declare type AvatarItem = {
+    src?: string;
+    name?: string;
+};
+export { AvatarItem }
+export { AvatarItem as AvatarItem_alias_1 }
+
+export declare function BadgeBlock({ text, variant, items, gap, className, }: BadgeBlockProps): JSX.Element | null;
+
+declare type BadgeBlockProps = {
+    /** Single badge text (backward compat). Ignored when `items` is set. */
+    text?: string;
+    variant?: BadgeVariant;
+    /** Multiple badges. Takes precedence over `text`/`variant`. */
+    items?: BadgeItem[];
+    gap?: number;
+    className?: string;
+};
+export { BadgeBlockProps }
+export { BadgeBlockProps as BadgeBlockProps_alias_1 }
+
+declare type BadgeItem = {
+    text: string;
+    variant?: BadgeVariant;
+    icon?: string;
+};
+export { BadgeItem }
+export { BadgeItem as BadgeItem_alias_1 }
+
+declare type BadgeVariant = "default" | "outline" | "success" | "warning" | "info";
+export { BadgeVariant }
+export { BadgeVariant as BadgeVariant_alias_1 }
+
+export declare function BeforeAfterBlock(props: BeforeAfterBlockProps): JSX.Element;
+
+declare type BeforeAfterBlockProps = {
+    before: BeforeAfterSide;
+    after: BeforeAfterSide;
+    style?: "split" | "swipe" | "stacked";
+    className?: string;
+};
+export { BeforeAfterBlockProps }
+export { BeforeAfterBlockProps as BeforeAfterBlockProps_alias_1 }
+
+declare type BeforeAfterSide = {
+    label: string;
+    items: string[];
+    color?: string;
+    icon?: string;
+};
+export { BeforeAfterSide }
+export { BeforeAfterSide as BeforeAfterSide_alias_1 }
+
+declare type BlobConfig = {
+    position: {
+        x: string;
+        y: string;
+    };
+    /** Explicit RGBA fill. Omit to inherit `--jy-blob-color` from the theme
+     *  (used by autogenerated random blobs so they match the active theme). */
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    size?: string;
+};
+export { BlobConfig }
+export { BlobConfig as BlobConfig_alias_1 }
+
+/** Metadata for each block type — seed for a future journey editor drag-and-drop palette */
+declare const BLOCK_META: Record<BlockType, {
+    label: string;
+    description: string;
+}>;
+export { BLOCK_META }
+export { BLOCK_META as BLOCK_META_alias_1 }
+
+export declare const BLOCK_REGISTRY: Record<BlockType, ComponentType<any>>;
+
+declare type BlockAnimation = {
+    /** Predefined animation preset. Defaults to "fade-in" */
+    preset?: AnimationPreset;
+    /** Duration in seconds. Defaults to 0.5 */
+    duration?: number;
+    /** Delay in seconds. If omitted, auto-calculated from block index (index * 0.08s) */
+    delay?: number;
+    /** If true, element reserves its space before the animation starts (animates opacity/transform only).
+     *  If false (default), element is hidden and pushes content down as it appears. */
+    reserveSpace?: boolean;
+    /** When to trigger the entrance animation.
+     *  "mount" (default) — animate immediately on mount.
+     *  "visible" — animate when the block enters the viewport (fires once). */
+    animateOn?: "mount" | "visible";
+};
+export { BlockAnimation }
+export { BlockAnimation as BlockAnimation_alias_1 }
+
+declare type BlockCondition = {
+    /** The step ID whose answer is checked */
+    answerKey: string;
+    /** Operator: defaults to "truthy" */
+    op?: "truthy" | "falsy" | "equals" | "includes" | "notEquals";
+    /** Value to compare against (for equals/includes/notEquals) */
+    value?: string | number;
+};
+export { BlockCondition }
+export { BlockCondition as BlockCondition_alias_1 }
+
+/**
+ * Discriminated union: `type` narrows `props` to the correct block-specific interface.
+ * e.g. `{ type: "heading" }` → `props: HeadingBlockProps`
+ */
+declare type BlockConfig = {
+    [K in BlockType]: {
+        type: K;
+        props: BlockPropsMap[K];
+    } & BlockConfigBase;
+}[BlockType];
+export { BlockConfig }
+export { BlockConfig as BlockConfig_alias_1 }
+
+/** Base fields shared by every block config entry */
+declare type BlockConfigBase = {
+    /** Optional stable anchor ID that scroll timelines can target */
+    anchorId?: string;
+    /** Optional Tailwind className override applied to the block wrapper */
+    className?: string;
+    /** Optional inline style override on the block wrapper */
+    style?: React.CSSProperties;
+    /** Optional animation override. Defaults to staggered fade-in */
+    animation?: BlockAnimation;
+    /** Optional exit animation played when the block disappears (e.g. condition becomes false) */
+    exitAnimation?: BlockExitAnimation;
+    /** If true, block is pinned to the bottom of the page outside the scrollable area */
+    sticky?: boolean;
+    /** Optional condition — block is only rendered if condition evaluates true */
+    condition?: BlockCondition;
+    /** Per-block override of the journey's `contentMaxWidth`. Numbers are interpreted as px;
+     *  strings are passed through as CSS (e.g. "32rem"). Use "none" to opt out of the journey
+     *  default and let this block fill the available width. */
+    maxWidth?: number | string | "none";
+};
+
+declare type BlockExitAnimation = {
+    /** Predefined exit animation preset. Defaults to "fade-out" */
+    preset?: ExitAnimationPreset;
+    /** Duration in seconds. Defaults to 0.35 */
+    duration?: number;
+    /** Delay in seconds before exit starts (after trigger). Defaults to 0 */
+    delay?: number;
+    /** Auto-hide: seconds after the block appears before it automatically exits.
+     *  Works independently of conditions — the block disappears on a timer. */
+    autoHideAfter?: number;
+};
+export { BlockExitAnimation }
+export { BlockExitAnimation as BlockExitAnimation_alias_1 }
+
+/** Maps each BlockType to its typed props interface */
+declare type BlockPropsMap = {
+    heading: HeadingBlockProps;
+    text: TextBlockProps;
+    image: ImageBlockProps;
+    button: ButtonBlockProps;
+    spacer: SpacerBlockProps;
+    divider: DividerBlockProps;
+    stat: StatBlockProps;
+    icon: IconBlockProps;
+    badge: BadgeBlockProps;
+    list: ListBlockProps;
+    comparison_bar: ComparisonBarBlockProps;
+    counter: CounterBlockProps;
+    decorated_text: DecoratedTextBlockProps;
+    quote: QuoteBlockProps;
+    video: VideoBlockProps;
+    card: CardBlockProps;
+    callout: CalloutBlockProps;
+    progress_bar: ProgressBarBlockProps;
+    lottie: LottieBlockProps;
+    carousel: CarouselBlockProps;
+    checklist: ChecklistBlockProps;
+    accordion: AccordionBlockProps;
+    columns: ColumnsBlockProps;
+    circular_progress: CircularProgressBlockProps;
+    line_chart: LineChartBlockProps;
+    avatar_group: AvatarGroupBlockProps;
+    table: TableBlockProps;
+    gravity_bin: GravityBinBlockProps;
+    timeline: TimelineBlockProps;
+    feature_row: FeatureRowBlockProps;
+    metric: MetricBlockProps;
+    device_frame: DeviceFrameBlockProps;
+    before_after: BeforeAfterBlockProps;
+    notification_stack: NotificationStackBlockProps;
+    floating_label: FloatingLabelBlockProps;
+    single_select: SingleSelectBlockProps;
+    multi_select: MultiSelectBlockProps;
+    pricing_plans: PricingPlansBlockProps;
+};
+export { BlockPropsMap }
+export { BlockPropsMap as BlockPropsMap_alias_1 }
+
+export declare function BlockRenderer({ blocks, layout, answers, onNext, onBack, onGoToStep, isLastStep, scrollViewportRef, wrapInScrollViewport, }: BlockRendererProps): JSX.Element;
+
+declare type BlockRendererProps = {
+    blocks: BlockConfig[];
+    layout?: PageLayout;
+    answers: JourneyAnswers;
+    onNext: () => void;
+    onBack: () => void;
+    onGoToStep?: (stepId: string) => void;
+    isLastStep?: boolean;
+    scrollViewportRef?: Ref<HTMLDivElement>;
+    wrapInScrollViewport?: boolean;
+};
+
+declare type BlockType = "heading" | "text" | "image" | "button" | "spacer" | "divider" | "stat" | "icon" | "badge" | "list" | "comparison_bar" | "counter" | "decorated_text" | "quote" | "video" | "card" | "callout" | "progress_bar" | "lottie" | "carousel" | "checklist" | "accordion" | "columns" | "circular_progress" | "line_chart" | "avatar_group" | "table" | "gravity_bin" | "timeline" | "feature_row" | "metric" | "device_frame" | "before_after" | "notification_stack" | "floating_label" | "single_select" | "multi_select" | "pricing_plans";
+export { BlockType }
+export { BlockType as BlockType_alias_1 }
+
+export declare function Button({ className, variant, size, asChild, ...props }: React_2.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React_2.JSX.Element;
+
+declare type ButtonAction = {
+    type: "next";
+} | {
+    type: "back";
+} | {
+    type: "skip";
+    skipTo?: string;
+} | {
+    type: "link";
+    url: string;
+    external?: boolean;
+    /** Final-step links complete before navigating by default. Set false to opt out, or true to force this on non-final steps. */
+    completeBeforeNavigate?: boolean;
+} | {
+    type: "purchase";
+    planVariable?: string;
+    discountVariable?: string;
+} | {
+    type: "open_discount_code";
+    variable: string;
+    planVariable?: string;
+    title?: string;
+    placeholder?: string;
+    applyLabel?: string;
+};
+export { ButtonAction }
+export { ButtonAction as ButtonAction_alias_1 }
+
+export declare function ButtonBlock({ label, action, variant, className, onNext, onBack, onGoToStep, onPurchase, onOpenDiscountCode, disabled, isLastStep, }: ButtonBlockComponentProps): JSX.Element;
+
+declare type ButtonBlockComponentProps = ButtonBlockProps & {
+    onNext?: () => void;
+    onBack?: () => void;
+    onGoToStep?: (stepId: string) => void;
+    /** Injected by BlockRenderer when action.type === "purchase". Fires purchase_intent event;
+     *  consumer takes over for payment and calls navigation actions when ready. */
+    onPurchase?: () => void;
+    /** Injected by BlockRenderer when action.type === "open_discount_code". */
+    onOpenDiscountCode?: () => void;
+    /** Injected by BlockRenderer when sibling input blocks have unmet validation. */
+    disabled?: boolean;
+    isLastStep?: boolean;
+};
+
+declare type ButtonBlockProps = {
+    label: string;
+    action: ButtonAction;
+    variant?: "default" | "outline" | "ghost" | "link";
+    className?: string;
+};
+export { ButtonBlockProps }
+export { ButtonBlockProps as ButtonBlockProps_alias_1 }
+
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "outline" | "ghost" | "destructive" | "secondary" | null | undefined;
+    size?: "icon" | "default" | "xs" | "sm" | "lg" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare function CalloutBlock({ text, title, variant, icon, className, }: CalloutBlockProps): JSX.Element;
+
+declare type CalloutBlockProps = {
+    text: string;
+    title?: string;
+    variant?: "info" | "warning" | "success" | "tip";
+    icon?: string;
+    className?: string;
+};
+export { CalloutBlockProps }
+export { CalloutBlockProps as CalloutBlockProps_alias_1 }
+
+export declare function CardBlock({ title, description, icon, image, variant, padding, borderRadius, className, }: CardBlockProps): JSX.Element;
+
+declare type CardBlockProps = {
+    title?: string;
+    description?: string;
+    icon?: string;
+    image?: string;
+    variant?: "default" | "outlined" | "elevated" | "glass";
+    padding?: number;
+    borderRadius?: number;
+    className?: string;
+};
+export { CardBlockProps }
+export { CardBlockProps as CardBlockProps_alias_1 }
+
+export declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React_2.ComponentProps<"div"> & CarouselProps): React_2.JSX.Element;
+
+export declare type CarouselApi = UseEmblaCarouselType[1];
+
+export declare function CarouselBlock({ items, autoplay, autoplayInterval, loop, showDots, showArrows, className, }: CarouselBlockProps): JSX.Element;
+
+declare type CarouselBlockProps = {
+    items: CarouselSlide[];
+    autoplay?: boolean;
+    autoplayInterval?: number;
+    loop?: boolean;
+    showDots?: boolean;
+    showArrows?: boolean;
+    className?: string;
+};
+export { CarouselBlockProps }
+export { CarouselBlockProps as CarouselBlockProps_alias_1 }
+
+export declare function CarouselContent({ className, ...props }: React_2.ComponentProps<"div">): React_2.JSX.Element;
+
+export declare function CarouselItem({ className, ...props }: React_2.ComponentProps<"div">): React_2.JSX.Element;
+
+export declare function CarouselNext({ className, variant, size, ...props }: React_2.ComponentProps<typeof Button>): React_2.JSX.Element;
+
+declare type CarouselOptions = UseCarouselParameters[0];
+
+declare type CarouselPlugin = UseCarouselParameters[1];
+
+export declare function CarouselPrevious({ className, variant, size, ...props }: React_2.ComponentProps<typeof Button>): React_2.JSX.Element;
+
+declare type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+
+declare type CarouselSlide = MediaSlide | QuoteSlide;
+export { CarouselSlide }
+export { CarouselSlide as CarouselSlide_alias_1 }
+
+declare type ChartLine = {
+    points: [number, number][];
+    color: string;
+    fill?: {
+        from: string;
+        to: string;
+        opacity?: number;
+    };
+    strokeWidth?: number;
+    dashed?: boolean;
+    endLabel?: string;
+    endIcon?: string;
+    endLabelColor?: string;
+    endLabelOffset?: {
+        x?: number;
+        y?: number;
+    };
+    endDot?: ChartLineEndDot;
+};
+export { ChartLine }
+export { ChartLine as ChartLine_alias_1 }
+
+declare type ChartLineEndDot = {
+    icon?: string;
+    lucideIcon?: string;
+    lucideIconColor?: string;
+    imageSrc?: string;
+    imageAlt?: string;
+    imageScale?: number;
+    color?: string;
+    gradient?: {
+        from: string;
+        to: string;
+        angle?: number;
+    };
+    size?: number;
+};
+export { ChartLineEndDot }
+export { ChartLineEndDot as ChartLineEndDot_alias_1 }
+
+export declare function Checkbox({ className, ...props }: React_2.ComponentProps<typeof Checkbox_2.Root>): React_2.JSX.Element;
+
+export declare function ChecklistBlock({ items, animateOnMount, staggerDelay, className, }: ChecklistBlockProps): JSX.Element;
+
+declare type ChecklistBlockProps = {
+    items: ChecklistItem[];
+    animateOnMount?: boolean;
+    staggerDelay?: number;
+    className?: string;
+};
+export { ChecklistBlockProps }
+export { ChecklistBlockProps as ChecklistBlockProps_alias_1 }
+
+declare type ChecklistItem = {
+    text?: string;
+    segments?: TextSegment[];
+    textColor?: string;
+    lineHeight?: string | number;
+    checked?: boolean;
+    icon?: string;
+    iconColor?: string;
+    iconGradient?: {
+        from: string;
+        to: string;
+    };
+    loadDelay?: number;
+    loadDuration?: number;
+};
+export { ChecklistItem }
+export { ChecklistItem as ChecklistItem_alias_1 }
+
+export declare function CircularProgressBlock({ segments, startDelay, size, strokeWidth, trackColor, color, gradient, showPercentage, percentageColor, percentageOpacity, percentageFontSize, hapticInterval, className, }: CircularProgressBlockProps): JSX.Element;
+
+declare type CircularProgressBlockProps = {
+    segments: ProgressSegment[];
+    startDelay?: number;
+    size?: number;
+    strokeWidth?: number;
+    trackColor?: string;
+    color?: string;
+    gradient?: {
+        from: string;
+        to: string;
+    };
+    showPercentage?: boolean;
+    percentageColor?: string;
+    percentageOpacity?: number;
+    percentageFontSize?: string;
+    hapticInterval?: number;
+    className?: string;
+};
+export { CircularProgressBlockProps }
+export { CircularProgressBlockProps as CircularProgressBlockProps_alias_1 }
+
+export declare function cn(...inputs: ClassValue[]): string;
+
+declare type ColumnConfig = {
+    blocks: BlockConfig[];
+    flex?: number;
+    /** Explicit CSS width (e.g. "75%", "200px"). Overrides flex when set. */
+    width?: string;
+};
+export { ColumnConfig }
+export { ColumnConfig as ColumnConfig_alias_1 }
+
+export declare function ColumnsBlock({ columns, gap, responsive, className, answers, onNext, onBack, onGoToStep, isLastStep, }: ColumnsBlockComponentProps): JSX.Element;
+
+declare type ColumnsBlockComponentProps = ColumnsBlockProps & {
+    answers?: JourneyAnswers;
+    onNext?: () => void;
+    onBack?: () => void;
+    onGoToStep?: (stepId: string) => void;
+    isLastStep?: boolean;
+};
+
+declare type ColumnsBlockProps = {
+    columns: ColumnConfig[];
+    gap?: number | string;
+    responsive?: boolean;
+    className?: string;
+};
+export { ColumnsBlockProps }
+export { ColumnsBlockProps as ColumnsBlockProps_alias_1 }
+
+declare type ComparisonBar = {
+    label: string;
+    value: number | string;
+    color?: string;
+    gradient?: GradientValue;
+    percentageColor?: string;
+};
+export { ComparisonBar }
+export { ComparisonBar as ComparisonBar_alias_1 }
+
+export declare function ComparisonBarBlock({ bars, showPercentage, maxBarHeight, barWidth, gap, animationDuration, staggerDelay, borderRadius, className, }: ComparisonBarBlockProps): JSX.Element;
+
+declare type ComparisonBarBlockProps = {
+    bars: ComparisonBar[];
+    showPercentage?: boolean;
+    maxBarHeight?: number;
+    barWidth?: number;
+    gap?: number;
+    animationDuration?: number;
+    staggerDelay?: number;
+    borderRadius?: number;
+    className?: string;
+};
+export { ComparisonBarBlockProps }
+export { ComparisonBarBlockProps as ComparisonBarBlockProps_alias_1 }
+
+declare type ComputedVariable = {
+    /** Variable name — must be a valid JS identifier. */
+    id: string;
+    /** Human-readable label for the journey editor. */
+    label?: string;
+    /** JS expression evaluated against current answers, e.g. "age >= 18 ? 'adult' : 'minor'" */
+    expression: string;
+};
+export { ComputedVariable }
+export { ComputedVariable as ComputedVariable_alias_1 }
+
+declare type ContinuousScrollTimelineEvent = ScrollTimelineEventBase & {
+    action: "continuous_scroll";
+    /** Scroll speed in px/sec */
+    speedPxPerSecond: number;
+    /** Stop condition for this continuous segment. Defaults to "next_event". */
+    until?: "next_event" | "end" | "user_interrupt";
+};
+export { ContinuousScrollTimelineEvent }
+export { ContinuousScrollTimelineEvent as ContinuousScrollTimelineEvent_alias_1 }
+
+export declare function CounterBlock({ value, prefix, suffix, startDelay, duration, decimals, hapticInterval, fontSize, fontWeight, color, gradient, fontFamily, className, }: CounterBlockProps): JSX.Element;
+
+declare type CounterBlockProps = {
+    value: number | string;
+    prefix?: string;
+    suffix?: string;
+    startDelay?: number;
+    duration?: number;
+    decimals?: number;
+    hapticInterval?: number;
+    fontSize?: string;
+    fontWeight?: string | number;
+    color?: string;
+    gradient?: GradientValue;
+    fontFamily?: string;
+    className?: string;
+};
+export { CounterBlockProps }
+export { CounterBlockProps as CounterBlockProps_alias_1 }
+
+export declare function CounterSelectStep({ config, answer, onAnswer, onNext, }: StepComponentProps): JSX.Element;
+
+declare type CounterStyle = {
+    /** Whether to show the gravity bin physics background. Default true */
+    showGravityBin?: boolean;
+    /** Matter.js gravity Y value. Default 1 */
+    gravity?: number;
+    /** Bounce restitution 0-1. Default 0.4 */
+    restitution?: number;
+    /** Body friction. Default 0.3 */
+    friction?: number;
+    /** Icon body radius in px. Default 20 */
+    iconSize?: number;
+    /** Max total count across all options */
+    maxTotal?: number;
+};
+export { CounterStyle }
+export { CounterStyle as CounterStyle_alias_1 }
+
+export declare function createCaptureEventId(runtime: Pick<RuntimeIds, "clientSessionId">, event: JourneyEvent, sequence: number): string;
+
+export declare function DecoratedTextBlock({ text, segments, leftImage, rightImage, imageSize, fontSize, fontWeight, lineHeight, color, gradient, textAlign, className, }: DecoratedTextBlockProps): JSX.Element;
+
+declare type DecoratedTextBlockProps = {
+    text?: string;
+    segments?: TextSegment[];
+    leftImage?: string;
+    rightImage?: string;
+    imageSize?: number;
+    fontSize?: string;
+    fontWeight?: string | number;
+    lineHeight?: string | number;
+    color?: string;
+    gradient?: GradientValue;
+    textAlign?: "left" | "center" | "right";
+    className?: string;
+};
+export { DecoratedTextBlockProps }
+export { DecoratedTextBlockProps as DecoratedTextBlockProps_alias_1 }
+
+export declare function DeviceFrameBlock({ src, alt, variant, shadow, mediaType, previewImage, playback, autoplay, loop, className, }: DeviceFrameBlockProps): JSX.Element;
+
+declare type DeviceFrameBlockProps = {
+    src: string;
+    alt?: string;
+    variant?: "iphone" | "android";
+    shadow?: boolean;
+    mediaType?: "image" | "video";
+    previewImage?: string;
+    playback?: DeviceFrameVideoPlayback;
+    autoplay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    controls?: boolean;
+    className?: string;
+};
+export { DeviceFrameBlockProps }
+export { DeviceFrameBlockProps as DeviceFrameBlockProps_alias_1 }
+
+export declare type DeviceFrameVideoPlayback = "paused" | "on_mount" | "on_view" | "on_click";
+
+export declare function discountAppliesToPlan(discount: AppliedDiscountAnswer | undefined, planId: string): discount is AppliedDiscountAnswer;
+
+declare type DiscountCodeApplyRequest = {
+    code: string;
+    variable: string;
+    planVariable?: string;
+    plan?: PricingPlan;
+    answers: JourneyAnswers;
+};
+export { DiscountCodeApplyRequest }
+export { DiscountCodeApplyRequest as DiscountCodeApplyRequest_alias_1 }
+
+declare type DiscountCodeApplyResult = {
+    valid: true;
+    code?: string;
+    planId?: string;
+    message?: string;
+    pricing?: AppliedDiscountPricing;
+    summaryLines?: DiscountCodeSummaryLine[];
+    metadata?: Record<string, unknown>;
+} | {
+    valid: false;
+    reason: string;
+    metadata?: Record<string, unknown>;
+};
+export { DiscountCodeApplyResult }
+export { DiscountCodeApplyResult as DiscountCodeApplyResult_alias_1 }
+
+declare function DiscountCodeDialog({ state, onClose, onApply, onClear, }: DiscountCodeDialogProps): JSX.Element;
+export { DiscountCodeDialog }
+export { DiscountCodeDialog as DiscountCodeDialog_alias_1 }
+
+declare type DiscountCodeDialogProps = {
+    state: DiscountCodeDialogState | null;
+    onClose: () => void;
+    onApply: (code: string, state: DiscountCodeDialogState) => Promise<DiscountCodeApplyResult>;
+    onClear: (state: DiscountCodeDialogState) => void;
+};
+
+declare type DiscountCodeDialogState = {
+    variable: string;
+    planVariable?: string;
+    plan?: PricingPlan;
+    initialCode?: string;
+    title?: string;
+    placeholder?: string;
+    applyLabel?: string;
+};
+export { DiscountCodeDialogState }
+export { DiscountCodeDialogState as DiscountCodeDialogState_alias_1 }
+
+declare type DiscountCodeSummaryLine = {
+    label: string;
+    value: string;
+};
+export { DiscountCodeSummaryLine }
+export { DiscountCodeSummaryLine as DiscountCodeSummaryLine_alias_1 }
+
+export declare function DividerBlock({ color, gradient, thickness, decorative, className, }: DividerBlockProps): JSX.Element;
+
+declare type DividerBlockProps = {
+    color?: string;
+    gradient?: GradientValue;
+    thickness?: number;
+    decorative?: "dots" | "diamond" | "wave" | "fade";
+    className?: string;
+};
+export { DividerBlockProps }
+export { DividerBlockProps as DividerBlockProps_alias_1 }
+
+/**
+ * Evaluates a BlockCondition against the current answers.
+ * Returns true if the block should be rendered.
+ */
+declare function evaluateCondition(condition: BlockCondition, answers: JourneyAnswers): boolean;
+export { evaluateCondition }
+export { evaluateCondition as evaluateCondition_alias_1 }
+
+declare type ExitAnimationPreset = "fade-out" | "slide-up" | "slide-down" | "slide-left" | "slide-right" | "scale-down" | "blur-out" | "none";
+export { ExitAnimationPreset }
+export { ExitAnimationPreset as ExitAnimationPreset_alias_1 }
+
+export declare function FeatureRowBlock({ title, description, icon, iconSize, iconColor, iconGradient, iconBg, iconBgColor, layout, className, }: FeatureRowBlockProps): JSX.Element;
+
+declare type FeatureRowBlockProps = {
+    title: string;
+    description?: string;
+    icon?: string;
+    iconSize?: number;
+    iconColor?: string;
+    iconGradient?: {
+        from: string;
+        to: string;
+    };
+    iconBg?: FeatureRowIconBg;
+    iconBgColor?: string;
+    layout?: "horizontal" | "vertical";
+    className?: string;
+};
+export { FeatureRowBlockProps }
+export { FeatureRowBlockProps as FeatureRowBlockProps_alias_1 }
+
+declare type FeatureRowIconBg = "circle" | "rounded-square" | "none";
+export { FeatureRowIconBg }
+export { FeatureRowIconBg as FeatureRowIconBg_alias_1 }
+
+declare type FetchState = {
+    status: "loading";
+} | {
+    status: "ready";
+    config: JourneyConfig;
+} | {
+    status: "error";
+    error: Error;
+};
+export { FetchState }
+export { FetchState as FetchState_alias_1 }
+
+export declare function FloatingLabelBlock({ text, variant, color, gradient, className, }: FloatingLabelBlockProps): JSX.Element;
+
+declare type FloatingLabelBlockProps = {
+    text: string;
+    variant?: "pill" | "badge" | "step";
+    color?: string;
+    gradient?: GradientValue;
+    className?: string;
+};
+export { FloatingLabelBlockProps }
+export { FloatingLabelBlockProps as FloatingLabelBlockProps_alias_1 }
+
+export declare const FOUNDERHQ_BASE_URL = "https://getfounderhq.com";
+
+/** Read the plan id from an answer that may be either the new flattened object or a legacy plain string id. */
+export declare function getSelectedPlanId(answer: StepAnswer | undefined): string;
+
+export declare type GradientValue = string | {
+    from: string;
+    to: string;
+    angle?: number;
+};
+
+declare function GravityBin({ items, height, gravity, restitution, friction, iconSize, interactive, className, }: GravityBinProps): JSX.Element;
+export { GravityBin }
+export { GravityBin as GravityBin_alias_1 }
+
+export declare function GravityBinBlock({ items: staticItems, fromAnswer, iconMap, height, gravity, restitution, friction, iconSize, interactive, className, answers, }: GravityBinBlockProps & {
+    answers?: JourneyAnswers;
+}): JSX.Element;
+
+declare type GravityBinBlockProps = {
+    /** Static items to render */
+    items?: GravityBinItem[];
+    /** Answer key to read items from (used with iconMap) */
+    fromAnswer?: string;
+    /** Maps answer keys to icon names when using fromAnswer */
+    iconMap?: Record<string, string>;
+    /** Container height CSS value. Default "300px" */
+    height?: string;
+    /** Physics gravity Y. Default 1 */
+    gravity?: number;
+    /** Bounce restitution 0-1. Default 0.4 */
+    restitution?: number;
+    /** Friction. Default 0.3 */
+    friction?: number;
+    /** Icon body radius in px. Default 20 */
+    iconSize?: number;
+    /** Whether items are draggable. Default false */
+    interactive?: boolean;
+    className?: string;
+};
+export { GravityBinBlockProps }
+export { GravityBinBlockProps as GravityBinBlockProps_alias_1 }
+
+declare type GravityBinItem = {
+    icon: string;
+    /** Optional image URL. If present, renders image instead of icon. */
+    image?: string;
+    count: number;
+};
+export { GravityBinItem }
+export { GravityBinItem as GravityBinItem_alias_1 }
+
+declare type GravityBinProps = {
+    /** Flat array of items — each entry = one physics body */
+    items: Array<{
+        id: string;
+        icon: string;
+        image?: string;
+    }>;
+    /** Container height CSS value. Default "100%" */
+    height?: string;
+    /** Matter.js gravity.y. Default 1 */
+    gravity?: number;
+    /** Bounce restitution 0-1. Default 0.4 */
+    restitution?: number;
+    /** Body friction. Default 0.3 */
+    friction?: number;
+    /** Radius of each icon circle body in px. Default 20 */
+    iconSize?: number;
+    /** Whether items are draggable. Default false */
+    interactive?: boolean;
+    className?: string;
+};
+export { GravityBinProps }
+export { GravityBinProps as GravityBinProps_alias_1 }
+
+/**
+ * Returns true if <SegmentedProgress /> will render visible progress UI
+ * for the given step. Keep in sync with the render logic below — used by
+ * JourneyShell to decide whether to reserve header space at all.
+ */
+declare function hasVisibleProgress(config: JourneyConfig, currentStepIndex: number): boolean;
+export { hasVisibleProgress }
+export { hasVisibleProgress as hasVisibleProgress_alias_1 }
+
+export declare function HeadingBlock({ text, segments, level, fontSize, fontFamily, fontStyle, fontWeight, lineHeight, color, gradient, textAlign, className, }: HeadingBlockProps): JSX.Element;
+
+declare type HeadingBlockProps = {
+    text?: string;
+    segments?: TextSegment[];
+    level?: "h1" | "h2" | "h3";
+    fontSize?: string;
+    fontFamily?: string;
+    fontStyle?: "normal" | "italic";
+    fontWeight?: string | number;
+    lineHeight?: string | number;
+    color?: string;
+    gradient?: GradientValue;
+    textAlign?: "left" | "center" | "right";
+    className?: string;
+};
+export { HeadingBlockProps }
+export { HeadingBlockProps as HeadingBlockProps_alias_1 }
+
+export declare function IconBlock({ name, size, color, gradient, className, }: IconBlockProps): JSX.Element;
+
+declare type IconBlockProps = {
+    name: string;
+    size?: number;
+    color?: string;
+    gradient?: {
+        from: string;
+        to: string;
+    };
+    className?: string;
+};
+export { IconBlockProps }
+export { IconBlockProps as IconBlockProps_alias_1 }
+
+export declare function ImageBlock({ src, alt, width, height, className }: ImageBlockProps): JSX.Element;
+
+declare type ImageBlockProps = {
+    src: string;
+    alt?: string;
+    width?: string;
+    height?: string;
+    className?: string;
+};
+export { ImageBlockProps }
+export { ImageBlockProps as ImageBlockProps_alias_1 }
+
+export declare function InfoPageStep({ config, onNext, isLastStep, }: StepComponentProps): JSX.Element | null;
+
+export declare function Input({ className, type, ...props }: React_2.ComponentProps<"input">): React_2.JSX.Element;
+
+export declare function InputStep({ config, answer, onAnswer, onNext, }: StepComponentProps): JSX.Element;
+
+export declare function isAppliedDiscountAnswer(answer: StepAnswer | undefined): answer is AppliedDiscountAnswer;
+
+/** True when an answer is the flattened plan object (vs legacy string id or unset). */
+export declare function isSelectedPlanAnswer(answer: StepAnswer | undefined): answer is SelectedPlanAnswer;
+
+declare function Journey({ apiKey, journeyId, config, baseUrl, storageKey, onEvent, className, theme, initialAnswers, initialOptions, onDiscountCodeApply, loadingComponent, errorComponent, capture, }: JourneyProps): JSX.Element;
+export { Journey }
+export { Journey as Journey_alias_1 }
+
+declare type JourneyActions = {
+    goNext: (answer?: StepAnswer) => void;
+    goBack: () => void;
+    goToStep: (stepId: string) => void;
+    setAnswer: (stepId: string, answer: StepAnswer) => void;
+    getCurrentStep: () => StepConfig;
+    getStepAnswer: (stepId: string) => StepAnswer | undefined;
+    isFirstStep: () => boolean;
+    isLastStep: () => boolean;
+    /** Fires a purchase_intent event without auto-navigating. Consumer takes over for payment,
+     *  then calls goNext/goToStep when ready. */
+    firePurchaseIntent: (variable: string, plan: PricingPlan, discount?: AppliedDiscountAnswer) => void;
+    openDiscountCodeDialog: (state: DiscountCodeDialogState) => void;
+};
+
+declare type JourneyAnswers = Record<string, StepAnswer>;
+export { JourneyAnswers }
+export { JourneyAnswers as JourneyAnswers_alias_1 }
+
+declare type JourneyCaptureConfig = JourneyCaptureOptions & {
+    apiKey: string;
+    journeyId: string;
+    baseUrl: string;
+};
+
+export declare type JourneyCaptureOption = false | JourneyCaptureConfig;
+
+declare type JourneyCaptureOptions = {
+    context?: Record<string, unknown>;
+    contextFactory?: () => Record<string, unknown> | null | undefined;
+    captureContext?: boolean;
+    redactUrlParams?: true | string[];
+    batchSize?: number;
+    flushIntervalMs?: number;
+    maxRetries?: number;
+};
+export { JourneyCaptureOptions }
+export { JourneyCaptureOptions as JourneyCaptureOptions_alias_1 }
+
+declare type JourneyConfig = {
+    arcs: Arc[];
+    steps: StepConfig[];
+    computedVariables?: ComputedVariable[];
+    /** Split the header progress bar into arc segments. Defaults to true. */
+    splitProgressByArcs?: boolean;
+    /** Show past and future arc segments. When false, only the current arc is shown. Defaults to true. */
+    showAllProgressArcs?: boolean;
+    /** Show arc progress segments that have no steps counted for progress. Defaults to false. */
+    showEmptyProgressArcs?: boolean;
+    /** Allow users to navigate backward through the journey. Defaults to true. */
+    allowBackNavigation?: boolean;
+    /** Show autogenerated background blobs for steps that do not define blobs explicitly. Defaults to true. */
+    showRandomBlobs?: boolean;
+    /** CSS class(es) applied to the journey root, e.g. "dark jy-dark-gold" or "jy-light jy-light-gold" */
+    theme?: string;
+    /** CSS variable overrides applied as inline styles on the journey root, e.g. { "--primary": "oklch(0.7 0.15 250)" } */
+    themeVariables?: Record<string, string>;
+    /** Background pattern overlay. Defaults to "grid-dots". */
+    backgroundPattern?: "none" | "grid-dots" | "grid-lines";
+    /** Default max-width for blocks on every page (centers them via `margin-inline: auto`).
+     *  Numbers are interpreted as px; strings are passed through as CSS. Individual blocks can
+     *  override or opt out via their own `maxWidth` (set to `"none"` to disable). When unset,
+     *  blocks fill the page width — except `timeline` and `notification_stack`, which default
+     *  to 400px because they read poorly when stretched. */
+    contentMaxWidth?: number | string;
+};
+export { JourneyConfig }
+export { JourneyConfig as JourneyConfig_alias_1 }
+
+declare const JourneyContext: Context<JourneyContextValue | null>;
+export { JourneyContext }
+export { JourneyContext as JourneyContext_alias_1 }
+
+declare type JourneyContextValue = {
+    state: JourneyState;
+    actions: JourneyActions;
+};
+
+declare type JourneyEvent = {
+    type: "session_start";
+    step: StepConfig;
+    answers: JourneyAnswers;
+    computedVariables: JourneyEventComputedVariables;
+    variables: string[];
+} | {
+    type: "step_view";
+    step: StepConfig;
+    answers: JourneyAnswers;
+    computedVariables: JourneyEventComputedVariables;
+    variables: string[];
+} | {
+    type: "step_submit";
+    step: StepConfig;
+    submitted: {
+        variable: string;
+        value: StepAnswer | undefined;
+    };
+    answers: JourneyAnswers;
+    computedVariables: JourneyEventComputedVariables;
+    variables: string[];
+} | {
+    type: "navigate";
+    from: StepConfig;
+    to: StepConfig;
+    direction: NavigationDirection;
+    answers: JourneyAnswers;
+    computedVariables: JourneyEventComputedVariables;
+} | {
+    type: "complete";
+    answers: JourneyAnswers;
+    computedVariables: JourneyEventComputedVariables;
+    variables: string[];
+} | {
+    /** Fired when the user clicks a button with action.type === "purchase".
+     *  Does NOT auto-navigate — the consumer takes over for payment, then calls
+     *  navigation actions (goNext/goToStep) from useJourneyActions(). */
+    type: "purchase_intent";
+    variable: string;
+    plan: PricingPlan;
+    discount?: AppliedDiscountAnswer;
+    stepId: string;
+    answers: JourneyAnswers;
+    computedVariables: JourneyEventComputedVariables;
+};
+export { JourneyEvent }
+export { JourneyEvent as JourneyEvent_alias_1 }
+
+declare type JourneyEventComputedVariables = JourneyAnswers;
+export { JourneyEventComputedVariables }
+export { JourneyEventComputedVariables as JourneyEventComputedVariables_alias_1 }
+
+declare type JourneyOptionOverrides = Record<string, StepOption[]>;
+export { JourneyOptionOverrides }
+export { JourneyOptionOverrides as JourneyOptionOverrides_alias_1 }
+
+declare type JourneyProps = {
+    apiKey: string;
+    journeyId: string;
+    /** Optional local config. Access is still validated with apiKey + journeyId before render. */
+    config?: JourneyConfig;
+    /** Local testing override only. Non-local values fall back to https://getfounderhq.com. */
+    baseUrl?: string;
+    storageKey?: string;
+    onEvent?: (event: JourneyEvent) => void;
+    /** Capture Journey events/responses to FounderHQ by default; pass false to opt out. */
+    capture?: false | JourneyCaptureOptions;
+    className?: string;
+    /** CSS class(es) for the journey root, e.g. "dark jy-dark-gold" or "jy-light jy-light-gold". Overrides config.theme when set. */
+    theme?: string;
+    /** Seed answers available at first render. Useful for runtime-injected data (e.g. live pricing plans referenced via `"${pricingPlans}"` templates). Keys declared in `computedVariables` are ignored because formulas own those values. */
+    initialAnswers?: JourneyAnswers;
+    /** Runtime option lists keyed by answer key (`step.variable ?? step.id`, or select block `props.variable`). Values override inspector-configured options for rendering only. */
+    initialOptions?: JourneyOptionOverrides;
+    /** Consumer-owned discount validation/repricing callback. Journeys only handles UI/state. */
+    onDiscountCodeApply?: (request: DiscountCodeApplyRequest) => Promise<DiscountCodeApplyResult> | DiscountCodeApplyResult;
+    /** Custom loading component shown while fetching config */
+    loadingComponent?: ReactNode;
+    /** Custom error component shown on fetch failure */
+    errorComponent?: (error: Error) => ReactNode;
+};
+export { JourneyProps }
+export { JourneyProps as JourneyProps_alias_1 }
+
+declare function JourneyProvider({ config: rawConfig, storageKey, theme, onEvent, initialAnswers, initialOptions, onDiscountCodeApply, children, }: JourneyProviderProps): JSX.Element;
+export { JourneyProvider }
+export { JourneyProvider as JourneyProvider_alias_1 }
+
+declare type JourneyProviderProps = {
+    config: JourneyConfig;
+    storageKey?: string;
+    /** Theme class override applied to the provider scope so global UI like dialogs inherits journey tokens. */
+    theme?: string;
+    onEvent?: (event: JourneyEvent) => void;
+    /** Runtime-injected answers that override persisted (sessionStorage) values *for keys that
+     *  appear in `initialAnswers`*. Other persisted keys (e.g. the user's in-progress selections)
+     *  are preserved across reloads.
+     *  Use this for dynamic data the consumer fetched at startup, e.g. pricing plans resolved
+     *  from StoreKit/Play Billing/Stripe: `{ pricingPlans: [...] }`. Keys declared in
+     *  `computedVariables` are ignored here because formulas own those values. Refreshed prices
+     *  always win over a stale snapshot in storage. */
+    initialAnswers?: JourneyAnswers;
+    /** Runtime option lists keyed by answer key (`step.variable ?? step.id`, or select block
+     *  `props.variable`). These override editor-configured options in the rendered journey only;
+     *  they are not persisted in answers. Event step configs omit option arrays. */
+    initialOptions?: JourneyOptionOverrides;
+    /** Consumer-owned discount validation/repricing callback. Journeys only handles UI/state. */
+    onDiscountCodeApply?: (request: DiscountCodeApplyRequest) => Promise<DiscountCodeApplyResult> | DiscountCodeApplyResult;
+    children: ReactNode;
+};
+export { JourneyProviderProps }
+export { JourneyProviderProps as JourneyProviderProps_alias_1 }
+
+declare function JourneyShell({ className, theme }?: {
+    className?: string;
+    theme?: string;
+}): JSX.Element;
+export { JourneyShell }
+export { JourneyShell as JourneyShell_alias_1 }
+
+declare type JourneyState = {
+    config: JourneyConfig;
+    currentStepIndex: number;
+    answers: JourneyAnswers;
+    direction: NavigationDirection;
+};
+
+export declare function LineChartBlock({ lines, width, height, yLabelGutter, yLabels, xLabels, animationDuration, startDelay, showGrid, axisColor, labelColor, className, }: LineChartBlockProps): JSX.Element;
+
+declare type LineChartBlockProps = {
+    lines: ChartLine[];
+    width?: number | string;
+    height?: number | string;
+    yLabelGutter?: number;
+    yLabels?: {
+        top?: string;
+        bottom?: string;
+        topAt?: number;
+        bottomAt?: number;
+    };
+    xLabels?: {
+        left?: string;
+        right?: string;
+        leftAt?: number;
+        rightAt?: number;
+    };
+    animationDuration?: number;
+    startDelay?: number;
+    showGrid?: boolean;
+    axisColor?: string;
+    labelColor?: string;
+    className?: string;
+};
+export { LineChartBlockProps }
+export { LineChartBlockProps as LineChartBlockProps_alias_1 }
+
+export declare function ListBlock({ items, style, className, }: ListBlockProps): JSX.Element;
+
+declare type ListBlockProps = {
+    items: string[];
+    style?: "bullet" | "numbered" | "check";
+    className?: string;
+};
+export { ListBlockProps }
+export { ListBlockProps as ListBlockProps_alias_1 }
+
+export declare function LottieBlock({ src, autoplay, loop, speed, width, height, className, }: LottieBlockProps): JSX.Element;
+
+declare type LottieBlockProps = {
+    src: string;
+    autoplay?: boolean;
+    loop?: boolean;
+    speed?: number;
+    width?: string;
+    height?: string;
+    className?: string;
+};
+export { LottieBlockProps }
+export { LottieBlockProps as LottieBlockProps_alias_1 }
+
+export declare function LucideStrokeGradient({ id, from, to, }: {
+    id: string;
+    from: string;
+    to: string;
+}): JSX.Element;
+
+declare type MediaSlide = {
+    type?: "media";
+    image?: string;
+    title?: string;
+    description?: string;
+};
+export { MediaSlide }
+export { MediaSlide as MediaSlide_alias_1 }
+
+export declare function MetricBlock({ value, prefix, suffix, label, description, icon, iconPosition, color, gradient, accentColor, variant, compact, duration, decimals, startDelay, className, }: MetricBlockProps): JSX.Element;
+
+declare type MetricBlockProps = {
+    value: number | string;
+    prefix?: string;
+    suffix?: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    iconPosition?: "top" | "left" | "left-inline";
+    color?: string;
+    gradient?: GradientValue;
+    accentColor?: string;
+    variant?: MetricVariant;
+    /** Compact/dense mode — smaller padding, font sizes, and icon. Designed for tight vertical stacks or side-by-side tiles in columns. */
+    compact?: boolean;
+    duration?: number;
+    decimals?: number;
+    startDelay?: number;
+    className?: string;
+};
+export { MetricBlockProps }
+export { MetricBlockProps as MetricBlockProps_alias_1 }
+
+declare type MetricVariant = "card" | "inline" | "minimal";
+export { MetricVariant }
+export { MetricVariant as MetricVariant_alias_1 }
+
+export declare function MultiSelectBlock({ variable, options, layout, iconIndicator, style, maxSelections, }: MultiSelectBlockProps): JSX.Element;
+
+declare type MultiSelectBlockProps = {
+    /** Variable name in `answers` that the user's picks are written to. Required. */
+    variable: string;
+    options: StepOption[];
+    /** Top-level shortcut. Wins over `style.layout`. */
+    layout?: "list" | "grid";
+    /** Top-level shortcut. Wins over `style.iconIndicator`. Required when options carry icons. */
+    iconIndicator?: boolean;
+    /** Finer styling (colors, hover/selected backgrounds, border radius). */
+    style?: WidgetStyle;
+    /** Hard cap; selecting beyond it replaces the most-recent pick. */
+    maxSelections?: number;
+    /** Minimum picks required before sibling next/skip buttons enable. */
+    minSelections?: number;
+};
+export { MultiSelectBlockProps }
+export { MultiSelectBlockProps as MultiSelectBlockProps_alias_1 }
+
+export declare function MultiSelectStep({ config, answer, onAnswer, onNext, }: StepComponentProps): JSX.Element;
+
+export declare function MultiSelectWidget({ options, value, onChange, style, maxSelections, inspectPathPrefix, scrollable, }: MultiSelectWidgetProps): JSX.Element;
+
+export declare type MultiSelectWidgetProps = {
+    options: StepOption[];
+    value: string[];
+    onChange: (next: string[]) => void;
+    style?: WidgetStyle;
+    /** Hard cap on selections — when reached, selecting a new option replaces the most recent. */
+    maxSelections?: number;
+    /** Prefix used for `data-inspect-path` on each rendered option. */
+    inspectPathPrefix?: string;
+    scrollable?: boolean;
+};
+
+declare type NavigationDirection = "forward" | "backward";
+export { NavigationDirection }
+export { NavigationDirection as NavigationDirection_alias_1 }
+
+/**
+ * Reorder config.steps to match the navigation order defined by arcs.
+ * Steps not in any arc are appended at the end.
+ */
+declare function normalizeStepOrder(config: JourneyConfig): JourneyConfig;
+export { normalizeStepOrder }
+export { normalizeStepOrder as normalizeStepOrder_alias_1 }
+
+declare type NotificationColor = "none" | "white" | "black" | "orange" | "indigo" | "green" | "sunset" | "blue" | "purple";
+export { NotificationColor }
+export { NotificationColor as NotificationColor_alias_1 }
+
+declare type NotificationItem = {
+    title: string;
+    message: string;
+    icon?: string;
+    time?: string;
+    color?: NotificationColor;
+};
+export { NotificationItem }
+export { NotificationItem as NotificationItem_alias_1 }
+
+export declare function NotificationStackBlock({ notifications, staggerDelay, className, }: NotificationStackBlockProps): JSX.Element;
+
+declare type NotificationStackBlockProps = {
+    notifications: NotificationItem[];
+    staggerDelay?: number;
+    className?: string;
+};
+export { NotificationStackBlockProps }
+export { NotificationStackBlockProps as NotificationStackBlockProps_alias_1 }
+
+export declare function OptionIcon({ icon, className, style, }: {
+    icon?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): JSX.Element | null;
+
+declare type PageLayout = {
+    /** Flex align-items. Defaults to "center" */
+    align?: "start" | "center" | "end" | "stretch";
+    /** Flex justify-content. Defaults to "center" */
+    justify?: "start" | "center" | "end" | "between" | "around";
+    /** Gap in rem units. Defaults to 2 */
+    gap?: number;
+    /** Flex direction. Defaults to "col" */
+    direction?: "col" | "row";
+    /** Text alignment. Defaults to "center" */
+    textAlign?: "left" | "center" | "right";
+    /** Max width CSS value. Defaults to none */
+    maxWidth?: string;
+    /** Extra Tailwind className on the page wrapper */
+    className?: string;
+};
+export { PageLayout }
+export { PageLayout as PageLayout_alias_1 }
+
+/**
+ * Converts a lightweight markdown string into TextSegment[].
+ *
+ * Supported syntax:
+ *   **bold**           → fontWeight: "bold"
+ *   *italic*           → fontStyle: "italic"
+ *   ~~strikethrough~~  → className: "line-through"
+ *   {#f87171}          → color (suffix after any closing marker)
+ *
+ * Examples:
+ *   "This is **bold** text"
+ *   "A *colored*{#f87171} word"
+ *   "~~old~~ vs **new**{#4ade80}"
+ *
+ * No nesting. Unmatched markers are literal text.
+ */
+export declare function parseMarkdown(input: string): TextSegment[];
+
+declare type PauseScrollTimelineEvent = ScrollTimelineEventBase & {
+    action: "pause_scroll";
+};
+export { PauseScrollTimelineEvent }
+export { PauseScrollTimelineEvent as PauseScrollTimelineEvent_alias_1 }
+
+declare type PricingPlan = {
+    /** String fields anywhere inside a plan support templates. `currentPlan` exposes this card's
+     *  flattened price/plan fields (`id`, `name`, `amount`, `currency`, `period`, `trialDays`, ...);
+     *  other answers from the journey are available as their own keys. */
+    /** Stable id. Stored in answers[variable] when selected; consumer maps id → payment-provider price ID. */
+    id: string;
+    /** Display name, e.g. "Pro", "Monthly", "Annual". */
+    name: string;
+    price: {
+        /** Numeric amount. Used for math/sorting and Intl currency formatting when `display` is unset. */
+        amount: number;
+        /** ISO 4217 currency code, e.g. "USD", "EUR", "GBP". */
+        currency: string;
+        /** Subscription period. Defaults to one-time when omitted. */
+        period?: PricingPlanPeriod;
+        /** Strikethrough original price, same currency. Only rendered when `display` is unset. */
+        originalAmount?: number;
+        /** Override the default period suffix ("/mo", "/yr", etc.) with custom text like "/seat/mo". */
+        perUnitLabel?: string;
+        /** Verbatim price string. When set, this is rendered as-is and Intl/period/originalAmount are skipped.
+         *  Use for store-localized strings (StoreKit/Play Billing already format) or special cases ("Free", "Custom"). */
+        display?: string;
+        /** Free trial period (StoreKit-compatible). Exposed as `currentPlan.trialDays` in plan templates. */
+        trial?: {
+            days: number;
+        };
+        /** Introductory pricing (StoreKit-compatible). Exposed as `currentPlan.introOffer` in plan templates. */
+        introOffer?: {
+            amount: number;
+            periods: number;
+            periodUnit: "day" | "week" | "month";
+        };
+    };
+    description?: string;
+    /** Small line rendered under the price. Example: `"${currentPlan.trialDays} days free"`.
+     *  Replaces the previously auto-derived
+     *  trial / intro-offer subtext — those are no longer rendered automatically. */
+    subtext?: string;
+    features?: PricingPlanFeature[];
+    /** Floating tag above the card, e.g. "7 Days Free", "Most Popular". */
+    badge?: string;
+    /** Lucide icon name; rendered via OptionIcon. */
+    icon?: string;
+    /** Optional visibility gate, evaluated against current answers. Reuses BlockCondition. */
+    condition?: BlockCondition;
+    /** Opaque pass-through for consumer use (Stripe price ID, RevenueCat package, App Store / Play Store
+     *  product ID, internal SKUs). The block reads nothing from this — it flows through the
+     *  purchase_intent event for the consumer's payment service. */
+    metadata?: Record<string, unknown>;
+};
+export { PricingPlan }
+export { PricingPlan as PricingPlan_alias_1 }
+
+/** A single feature row in a plan. Strings render as a checkmarked bullet in featured/minimal,
+ *  and as a ✓ in the comparison style. Object form `{ key, value }` lets the comparison style
+ *  group rows by `key` and show different `value`s per plan (e.g. "Storage: 10GB" vs "100GB"). */
+declare type PricingPlanFeature = string | {
+    key: string;
+    value: string | boolean;
+};
+export { PricingPlanFeature }
+export { PricingPlanFeature as PricingPlanFeature_alias_1 }
+
+declare type PricingPlanPeriod = "day" | "week" | "month" | "year" | "one_time";
+export { PricingPlanPeriod }
+export { PricingPlanPeriod as PricingPlanPeriod_alias_1 }
+
+export declare function PricingPlansBlock({ variable, plans, cardStyle, layout, style, defaultPlanId, discountVariable, showDecimals, }: PricingPlansBlockProps): JSX.Element;
+
+declare type PricingPlansBlockProps = {
+    /** Variable name in `answers` where the selected plan id is written. Required. */
+    variable: string;
+    /** Plan list, or a whole-value template string like `"${pricingPlans}"` that resolves to one
+     *  at render time (used for dynamic StoreKit/Stripe pricing fed in via `answers`). */
+    plans: PricingPlan[] | string;
+    /** Card visual style. Defaults to "featured". */
+    cardStyle?: "featured" | "minimal" | "comparison";
+    /** Layout for featured/minimal. Defaults to "list". Ignored when cardStyle="comparison". */
+    layout?: "list" | "grid";
+    /** When true, sibling button blocks with action.type "next", "skip", or "purchase" auto-disable until a plan is selected. */
+    required?: boolean;
+    /** When set and no answer exists for `variable` yet, this plan id is auto-selected on mount. */
+    defaultPlanId?: string;
+    /** Optional answer key containing an applied discount. Used only for display; consumers own pricing math. */
+    discountVariable?: string;
+    /** Whether to render currency decimals (e.g. $29.00 vs $29). Defaults to true.
+     *  Set false for currencies like JPY/KRW where pricing is conventionally whole-unit. */
+    showDecimals?: boolean;
+    style?: PricingStyle;
+};
+export { PricingPlansBlockProps }
+export { PricingPlansBlockProps as PricingPlansBlockProps_alias_1 }
+
+export declare function PricingPlansWidget({ plans, value, onChange, cardStyle, layout, style, showDecimals, discountVariable, answers, inspectPathPrefix, }: PricingPlansWidgetProps): JSX.Element;
+
+export declare type PricingPlansWidgetProps = {
+    /** Resolved plan list. Accepts a string for the templated config form (`"${pricingPlans}"`)
+     *  that hasn't yet been resolved — the widget treats it as empty. */
+    plans: PricingPlan[] | string;
+    value: string;
+    onChange: (next: string) => void;
+    cardStyle?: "featured" | "minimal" | "comparison";
+    layout?: "list" | "grid";
+    style?: PricingStyle;
+    /** Whether to render currency decimals. Defaults to true (Intl default — usually 2 digits). */
+    showDecimals?: boolean;
+    /** Optional answer key containing an applied discount used for display only. */
+    discountVariable?: string;
+    /** Current answers, used to evaluate per-plan `condition` for visibility. */
+    answers: JourneyAnswers;
+    inspectPathPrefix?: string;
+};
+
+/** Pricing-specific styling, layered on top of WidgetStyle for shared card chrome. */
+declare type PricingStyle = Partial<WidgetStyle> & {
+    badgeBackground?: string;
+    badgeColor?: string;
+};
+export { PricingStyle }
+export { PricingStyle as PricingStyle_alias_1 }
+
+export declare function ProgressBarBlock({ value, label, color, gradient, height, animated, showPercentage, borderRadius, className, }: ProgressBarBlockProps): JSX.Element;
+
+declare type ProgressBarBlockProps = {
+    value: number | string;
+    label?: string;
+    color?: string;
+    gradient?: GradientValue;
+    height?: number;
+    animated?: boolean;
+    showPercentage?: boolean;
+    borderRadius?: number;
+    className?: string;
+};
+export { ProgressBarBlockProps }
+export { ProgressBarBlockProps as ProgressBarBlockProps_alias_1 }
+
+declare type ProgressSegment = {
+    to: number | string;
+    duration: number;
+};
+export { ProgressSegment }
+export { ProgressSegment as ProgressSegment_alias_1 }
+
+export declare function QuoteBlock({ quote, author, role, avatar, stars, className, }: QuoteBlockProps): JSX.Element;
+
+declare type QuoteBlockProps = {
+    quote: string;
+    author: string;
+    role?: string;
+    avatar?: string;
+    stars?: number;
+    className?: string;
+};
+export { QuoteBlockProps }
+export { QuoteBlockProps as QuoteBlockProps_alias_1 }
+
+declare type QuoteSlide = {
+    type: "quote";
+    quote: string;
+    author: string;
+    role?: string;
+    avatar?: string;
+    stars?: number;
+};
+export { QuoteSlide }
+export { QuoteSlide as QuoteSlide_alias_1 }
+
+export declare function RadioGroup({ className, ...props }: React_2.ComponentProps<typeof RadioGroup_2.Root>): React_2.JSX.Element;
+
+export declare function RadioGroupItem({ className, ...props }: React_2.ComponentProps<typeof RadioGroup_2.Item>): React_2.JSX.Element;
+
+export declare const renderTemplate: (template: string, variables: Record<string, unknown>, fallback: string) => string;
+
+/**
+ * Evaluates all computed variable expressions against the current answers.
+ * Returns a new answers object with computed values merged in.
+ */
+declare function resolveComputedVariables(computedVariables: ComputedVariable[] | undefined, answers: JourneyAnswers): JourneyAnswers;
+export { resolveComputedVariables }
+export { resolveComputedVariables as resolveComputedVariables_alias_1 }
+
+/**
+ * Evaluates all computed variable expressions against the current answers.
+ * Returns only the computed values.
+ * Computed variable ids are formula-owned; if a raw answer has the same key,
+ * the computed value wins in the merged result.
+ *
+ * Variables are evaluated in order so later ones can reference earlier ones.
+ */
+declare function resolveComputedVariableValues(computedVariables: ComputedVariable[] | undefined, answers: JourneyAnswers): JourneyAnswers;
+export { resolveComputedVariableValues }
+export { resolveComputedVariableValues as resolveComputedVariableValues_alias_1 }
+
+export declare function resolveGradient(gradient: GradientValue | undefined): string | undefined;
+
+export declare function resolveJourneyBaseUrl(baseUrl?: string): string;
+
+/** Resolve templated strings anywhere inside a plan with `currentPlan` scoped to that plan. */
+export declare function resolvePricingPlanTemplates(plan: PricingPlan, answers: JourneyAnswers): PricingPlan;
+
+/** Resolves an explicit gradient prop into a CSS background string. */
+export declare function resolveSelectedBorderGradient(gradient: GradientValue | undefined, 
+/** Default angle to use for object-form gradients. PlanCard historically used 135. */
+defaultAngle?: number): string | undefined;
+
+/**
+ * Resolves ${expression} template literals in a string using onboarding answers as variables.
+ * Supports full JS expressions: ${name.toUpperCase()}, ${goals.length}, ternaries, etc.
+ */
+export declare function resolveTemplate(template: string, answers: JourneyAnswers): string;
+
+/**
+ * Recursively resolves all string values in a props object.
+ * Handles nested objects and arrays. Non-string values pass through unchanged.
+ *
+ * Strings that are a single whole-value `${var}` reference resolve to the raw
+ * variable value (object/array/etc); mid-string templates keep string-coercion.
+ */
+export declare function resolveTemplateProps(props: Record<string, unknown>, answers: JourneyAnswers): Record<string, unknown>;
+
+export declare function RichText({ content, className, style }: RichTextProps): JSX.Element;
+
+export declare type RichTextProps = {
+    /** Simple string or array of styled segments */
+    content: string | TextSegment[];
+    className?: string;
+    style?: React.CSSProperties;
+};
+
+declare type RoutingRule = {
+    /** Single condition or array of conditions to evaluate */
+    when: BlockCondition | BlockCondition[];
+    /** How to combine multiple conditions: "all" = AND (default), "any" = OR */
+    match?: "all" | "any";
+    /** Step ID to navigate to when this rule matches */
+    goTo: string;
+};
+export { RoutingRule }
+export { RoutingRule as RoutingRule_alias_1 }
+
+declare type RuntimeIds = {
+    journeyId: string;
+    visitorId: string;
+    clientSessionId: string;
+    queueKey: string;
+};
+
+export declare function sanitizeSvgId(id: string): string;
+
+export declare const ScrollFade: ForwardRefExoticComponent<ScrollFadeProps & RefAttributes<HTMLDivElement>>;
+
+declare type ScrollFadeProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+
+declare type ScrollTimelineBehavior = "auto" | "smooth";
+export { ScrollTimelineBehavior }
+export { ScrollTimelineBehavior as ScrollTimelineBehavior_alias_1 }
+
+declare type ScrollTimelineEvent = ScrollToTimelineEvent | ContinuousScrollTimelineEvent | PauseScrollTimelineEvent;
+export { ScrollTimelineEvent }
+export { ScrollTimelineEvent as ScrollTimelineEvent_alias_1 }
+
+export declare type ScrollTimelineEventBase = {
+    /** Stable event ID for editor bookkeeping and future references */
+    id: string;
+    /** Time offset from step mount in seconds */
+    at: number;
+};
+
+declare type ScrollToTimelineEvent = ScrollTimelineEventBase & {
+    action: "scroll_to";
+    /** Target location. Use "anchor" for a block anchorId, or top/bottom edges of the info page. */
+    target: "anchor" | "top" | "bottom";
+    /** Required when target is "anchor" */
+    targetId?: string;
+    /** Alignment within the viewport. Defaults to "start". */
+    block?: "start" | "center" | "end";
+    /** Native scroll behavior. Defaults to "smooth". */
+    behavior?: ScrollTimelineBehavior;
+};
+export { ScrollToTimelineEvent }
+export { ScrollToTimelineEvent as ScrollToTimelineEvent_alias_1 }
+
+declare function SegmentedProgress(): JSX.Element | null;
+export { SegmentedProgress }
+export { SegmentedProgress as SegmentedProgress_alias_1 }
+
+export declare function SelectCard({ children, id, index, isSelected, style, hoveredId, onHover, disabled, "data-inspect-path": inspectPath, }: SelectCardProps): JSX.Element;
+
+declare type SelectCardProps = {
+    children: React.ReactNode;
+    id: string;
+    index?: number;
+    isSelected: boolean;
+    style?: WidgetStyle;
+    hoveredId: string | null;
+    onHover: (id: string | null) => void;
+    disabled?: boolean;
+    "data-inspect-path"?: string;
+};
+
+/** CSS variable holding the theme-level default selected border gradient. */
+export declare const SELECTED_BORDER_GRADIENT_VAR = "--jy-selected-border-gradient";
+
+export declare const SELECTED_BORDER_WIDTH_VAR = "--jy-selected-border-width";
+
+/** CSS background expression for the selected border wrapper.
+ *  Prefers the explicit prop, then falls back to the theme variable. The CSS var
+ *  itself acts as the final no-op fallback (resolves to nothing → fully
+ *  transparent wrapper, so the wrapped card visually identical to no border). */
+export declare function selectedBorderBackground(gradient: GradientValue | undefined): string;
+
+/** CSS expression for the selected border thickness, in pixels. */
+export declare function selectedBorderWidthExpr(width: number | undefined): string;
+
+/** Flattened plan snapshot stored in `answers[variable]` when a pricing_plans block selection is made.
+ *  Mirrors `PricingPlan` but lifts `price.*` fields to the top level so templates can use
+ *  `${selectedPlan.amount}` instead of `${selectedPlan.price.amount}`.
+ *  Persisted across reloads via storage; legacy plain-string `id` answers are upgraded on mount. */
+declare type SelectedPlanAnswer = {
+    id: string;
+    name: string;
+    amount: number;
+    currency: string;
+    period?: PricingPlanPeriod;
+    originalAmount?: number;
+    perUnitLabel?: string;
+    display?: string;
+    trialDays?: number;
+    introOffer?: {
+        amount: number;
+        periods: number;
+        periodUnit: "day" | "week" | "month";
+    };
+    description?: string;
+    features?: PricingPlanFeature[];
+    badge?: string;
+    icon?: string;
+    metadata?: Record<string, unknown>;
+};
+export { SelectedPlanAnswer }
+export { SelectedPlanAnswer as SelectedPlanAnswer_alias_1 }
+
+export declare function SingleSelectBlock({ variable, options, layout, iconIndicator, style, searchThreshold, }: SingleSelectBlockProps): JSX.Element;
+
+declare type SingleSelectBlockProps = {
+    /** Variable name in `answers` that the user's pick is written to. Required. */
+    variable: string;
+    options: StepOption[];
+    /** Top-level shortcut. Wins over `style.layout`. */
+    layout?: "list" | "grid" | "segmented";
+    /** Top-level shortcut. Wins over `style.iconIndicator`. Required when options carry icons. */
+    iconIndicator?: boolean;
+    /** Finer styling (colors, hover/selected backgrounds, border radius). */
+    style?: WidgetStyle;
+    searchThreshold?: number;
+    /** When true, sibling next/skip buttons on the same page are disabled until a pick exists. */
+    required?: boolean;
+};
+export { SingleSelectBlockProps }
+export { SingleSelectBlockProps as SingleSelectBlockProps_alias_1 }
+
+export declare function SingleSelectStep({ config, answer, onAnswer, onNext, }: StepComponentProps): JSX.Element;
+
+export declare function SingleSelectWidget({ options, value, onChange, style, searchThreshold, autoAdvance, onAutoAdvance, inspectPathPrefix, scrollable, }: SingleSelectWidgetProps): JSX.Element;
+
+export declare type SingleSelectWidgetProps = {
+    options: StepOption[];
+    value: string;
+    onChange: (next: string) => void;
+    style?: WidgetStyle;
+    searchThreshold?: number;
+    autoAdvance?: boolean;
+    onAutoAdvance?: () => void;
+    /** Prefix used for `data-inspect-path` on each rendered option (e.g. "options" or "props.options"). */
+    inspectPathPrefix?: string;
+    /** When true, wraps options list in a ScrollFade. Steps want this; embedded blocks usually don't. */
+    scrollable?: boolean;
+};
+
+export declare function SliderStep({ config, answer, onAnswer, onNext, }: StepComponentProps): JSX.Element;
+
+declare type SliderStyle = {
+    trackFillColor?: string;
+    trackFillGradient?: string;
+    trackBgColor?: string;
+    trackHeight?: number;
+    thumbColor?: string;
+    thumbWidth?: number;
+    thumbHeight?: number;
+    thumbBorderRadius?: string;
+    thumbShadow?: string;
+    valueColor?: string;
+    valueGradient?: string;
+    valueTemplate?: string;
+    valueDecimals?: number;
+    dynamicTextSize?: boolean;
+    reverseDynamicTextSize?: boolean;
+    minFontSize?: number;
+    maxFontSize?: number;
+    snapPoints?: number;
+    haptics?: boolean;
+    /** Initial slider value on page load. Defaults to midpoint of min–max. */
+    defaultValue?: number;
+};
+export { SliderStyle }
+export { SliderStyle as SliderStyle_alias_1 }
+
+export declare function SpacerBlock({ size }: SpacerBlockProps): JSX.Element;
+
+declare type SpacerBlockProps = {
+    size?: number;
+};
+export { SpacerBlockProps }
+export { SpacerBlockProps as SpacerBlockProps_alias_1 }
+
+export declare function StatBlock({ value, label, className }: StatBlockProps): JSX.Element;
+
+declare type StatBlockProps = {
+    value: string;
+    label: string;
+    className?: string;
+};
+export { StatBlockProps }
+export { StatBlockProps as StatBlockProps_alias_1 }
+
+declare type StepAnswer = string | string[] | number | boolean | Record<string, string> | Record<string, number> | SelectedPlanAnswer | AppliedDiscountAnswer | readonly PricingPlan[] | null;
+export { StepAnswer }
+export { StepAnswer as StepAnswer_alias_1 }
+
+declare type StepBackground = {
+    color?: string;
+    gradient?: string;
+    image?: string;
+};
+export { StepBackground }
+export { StepBackground as StepBackground_alias_1 }
+
+declare type StepComponentProps = {
+    config: StepConfig;
+    answer: StepAnswer | undefined;
+    onAnswer: (answer: StepAnswer) => void;
+    onNext: () => void;
+    isLastStep?: boolean;
+};
+export { StepComponentProps }
+export { StepComponentProps as StepComponentProps_alias_1 }
+
+declare type StepConfig = {
+    id: string;
+    type: StepType;
+    /** Custom variable name for storing this step's answer. Defaults to `id`. */
+    variable?: string;
+    preface?: string;
+    question?: string;
+    description?: string;
+    options?: StepOption[];
+    validation?: StepValidation;
+    fields?: StepField[];
+    background?: StepBackground;
+    style?: WidgetStyle;
+    buttonText?: string;
+    /** Centered text shown sticky just above the CTA button */
+    footerText?: string;
+    /** If true, hides the Next button and auto-advances when an option is selected (single_select only) */
+    autoAdvance?: boolean;
+    searchThreshold?: number;
+    sliderStyle?: SliderStyle;
+    swipeCards?: SwipeCardItem[];
+    swipeLabels?: SwipeLabels;
+    swipeIconAlign?: SwipeCardAlign;
+    swipeTextAlign?: SwipeCardAlign;
+    swipeIconStyle?: SwipeIconStyle;
+    swipeIconColor?: string;
+    counterStyle?: CounterStyle;
+    showProgress?: boolean;
+    countsForProgress?: boolean;
+    /** Per-step override for back navigation. When set, takes precedence over the journey-level
+     *  `allowBackNavigation`. Useful for confirmation/success pages where the user should not
+     *  be able to walk back into the form. */
+    allowBackNavigation?: boolean;
+    customComponentId?: string;
+    computeEndpoint?: string;
+    inputSteps?: string[];
+    /** Block-based composition for info_page steps */
+    blocks?: BlockConfig[];
+    /** Layout settings for the block-based page */
+    layout?: PageLayout;
+    /** Gradient blob configuration for animated background orbs (1-5 blobs per step) */
+    blobs?: BlobConfig[];
+    /** Conditional routing — determines which step to navigate to based on answers */
+    routing?: StepRouting;
+    /** Optional timeline of staggered scroll actions for info_page steps */
+    scrollTimeline?: StepScrollTimeline;
+};
+export { StepConfig }
+export { StepConfig as StepConfig_alias_1 }
+
+declare type StepField = {
+    id: string;
+    type: "text" | "email" | "number" | "tel";
+    label: string;
+    placeholder?: string;
+    required?: boolean;
+    min?: number;
+    max?: number;
+    options?: StepOption[];
+    /** Custom variable name for this field in the answers Record. Defaults to `id`. */
+    variable?: string;
+};
+export { StepField }
+export { StepField as StepField_alias_1 }
+
+declare type StepOption = {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    /** Optional image URL used in gravity bin physics visualization */
+    image?: string;
+};
+export { StepOption }
+export { StepOption as StepOption_alias_1 }
+
+declare function StepRenderer({ config }: {
+    config: StepConfig;
+}): JSX.Element;
+export { StepRenderer }
+export { StepRenderer as StepRenderer_alias_1 }
+
+declare type StepRouting = {
+    /** Evaluated top-to-bottom; first matching rule wins */
+    conditions: RoutingRule[];
+    /** Fallback step ID if no condition matches. Omit to use next sequential step. */
+    default?: string;
+};
+export { StepRouting }
+export { StepRouting as StepRouting_alias_1 }
+
+declare type StepScrollTimeline = {
+    /** Pause the timeline when the user scrolls, taps, wheels, or presses keys. Defaults to true. */
+    pauseOnUserInput?: boolean;
+    /** Optional auto-resume delay after user interruption, in seconds. */
+    resumeAfter?: number;
+    /** Ordered timeline of scroll actions for info pages. */
+    events: ScrollTimelineEvent[];
+};
+export { StepScrollTimeline }
+export { StepScrollTimeline as StepScrollTimeline_alias_1 }
+
+declare type StepType = "single_select" | "multi_select" | "input" | "slider" | "swipe_cards" | "counter_select" | "info_page" | "computed" | "custom";
+export { StepType }
+export { StepType as StepType_alias_1 }
+
+declare type StepValidation = {
+    required?: boolean;
+    min?: number;
+    max?: number;
+};
+export { StepValidation }
+export { StepValidation as StepValidation_alias_1 }
+
+declare type SwipeCardAlign = "left" | "center" | "right";
+export { SwipeCardAlign }
+export { SwipeCardAlign as SwipeCardAlign_alias_1 }
+
+declare type SwipeCardItem = {
+    variable: string;
+    text: string;
+    description?: string;
+    icon?: string;
+};
+export { SwipeCardItem }
+export { SwipeCardItem as SwipeCardItem_alias_1 }
+
+export declare function SwipeCardsStep({ config, answer, onAnswer, onNext, }: StepComponentProps): JSX.Element;
+
+declare type SwipeIconStyle = "circle" | "bare";
+export { SwipeIconStyle }
+export { SwipeIconStyle as SwipeIconStyle_alias_1 }
+
+declare type SwipeLabels = {
+    yes?: string;
+    no?: string;
+};
+export { SwipeLabels }
+export { SwipeLabels as SwipeLabels_alias_1 }
+
+export declare function TableBlock({ rowLabels, columns, highlightColor, highlightBorderRadius, rowLabelColor, headerColor, dividerColor, className, }: TableBlockProps): JSX.Element;
+
+declare type TableBlockProps = {
+    rowLabels: TableRowLabel[];
+    columns: TableColumn[];
+    highlightColor?: string;
+    highlightBorderRadius?: number;
+    rowLabelColor?: string;
+    headerColor?: string;
+    dividerColor?: string;
+    className?: string;
+};
+export { TableBlockProps }
+export { TableBlockProps as TableBlockProps_alias_1 }
+
+declare type TableCell = string | {
+    type: "check";
+    color?: string;
+    iconLabel?: string;
+    iconTooltip?: string;
+} | {
+    type: "cross";
+    color?: string;
+    iconLabel?: string;
+    iconTooltip?: string;
+} | {
+    type: "lock";
+    color?: string;
+    iconLabel?: string;
+    iconTooltip?: string;
+} | {
+    type: "warning";
+    color?: string;
+    iconLabel?: string;
+    iconTooltip?: string;
+} | {
+    type: "icon";
+    name: string;
+    color?: string;
+    size?: number;
+    iconLabel?: string;
+    iconTooltip?: string;
+} | {
+    type: "text";
+    text: string;
+    color?: string;
+    fontSize?: string;
+    fontWeight?: string | number;
+};
+export { TableCell }
+export { TableCell as TableCell_alias_1 }
+
+declare type TableColumn = {
+    header: string;
+    headerImage?: string;
+    highlight?: boolean;
+    cells: TableCell[];
+};
+export { TableColumn }
+export { TableColumn as TableColumn_alias_1 }
+
+declare type TableRowLabel = string | {
+    text: string;
+    icon?: string;
+    iconColor?: string;
+};
+export { TableRowLabel }
+export { TableRowLabel as TableRowLabel_alias_1 }
+
+export declare function TextBlock({ text, segments, variant, fontSize, fontFamily, fontStyle, fontWeight, lineHeight, color, gradient, textAlign, className, }: TextBlockProps): JSX.Element;
+
+declare type TextBlockProps = {
+    text?: string;
+    segments?: TextSegment[];
+    variant?: "subtitle" | "body" | "caption";
+    fontSize?: string;
+    fontFamily?: string;
+    fontStyle?: "normal" | "italic";
+    fontWeight?: string | number;
+    lineHeight?: string | number;
+    color?: string;
+    gradient?: GradientValue;
+    textAlign?: "left" | "center" | "right";
+    className?: string;
+};
+export { TextBlockProps }
+export { TextBlockProps as TextBlockProps_alias_1 }
+
+/** A styled span within a text/heading block for inline color, gradient, weight, etc.
+ *  When `type === "icon"`, `text` is interpreted as a Lucide icon name (or emoji fallback)
+ *  and the segment renders as an inline icon sized to the surrounding font. */
+declare type TextSegment = {
+    /** "text" (default) renders `text` as a styled span. "icon" renders `text` as an inline icon. */
+    type?: "text" | "icon";
+    text: string;
+    color?: string;
+    /** CSS gradient string or { from, to, angle? } for gradient text */
+    gradient?: GradientValue;
+    fontWeight?: string | number;
+    fontStyle?: "normal" | "italic";
+    fontSize?: string;
+    fontFamily?: string;
+    lineHeight?: string | number;
+    className?: string;
+};
+export { TextSegment }
+export { TextSegment as TextSegment_alias_1 }
+
+declare function TimelineBlock({ items, iconPlacement, labelPlacement, nodeSize, lineThickness, itemSpacing, titleDescGap, lineStyle, lineColor, lineOpacity, startLine, endLine, animated, entryAnimation, staggerDelay, className, }: TimelineBlockProps): JSX.Element;
+export { TimelineBlock }
+export { TimelineBlock as TimelineBlock_alias_1 }
+
+declare type TimelineBlockProps = {
+    items: TimelineItem[];
+    /** Where the item icon renders. Default "node" (inside a filled badge).
+     *  "content" = above the title (old look). "before-title" = inline before title. "none" = hide icon. */
+    iconPlacement?: "node" | "content" | "before-title" | "none";
+    /** Where the item label renders. Default "hidden" (title IS the time).
+     *  "above" = small uppercase label above title (old look). */
+    labelPlacement?: "above" | "hidden";
+    /** Node diameter in px. Default 44. */
+    nodeSize?: number;
+    /** Connecting line thickness in px. Default 3. */
+    lineThickness?: number;
+    /** Vertical gap (px) between items. Default `max(16, nodeSize * 0.4)`. Increase to breathe long descriptions. */
+    itemSpacing?: number;
+    /** Vertical gap (px) between an item's title and its description. Default 6 when `iconPlacement="node"`, else 4. */
+    titleDescGap?: number;
+    lineStyle?: "solid" | "dashed";
+    /** Fallback for any item that doesn't set its own `lineColor`. Default `rgba(255,255,255,0.1)`. */
+    lineColor?: TimelineColor;
+    /** Fallback line opacity (0–1) for any item that doesn't set its own `lineOpacity`. Default 1. */
+    lineOpacity?: number;
+    /** Line segment rendered above the first item. */
+    startLine?: {
+        show?: boolean;
+        feathered?: boolean;
+        color?: TimelineColor;
+        opacity?: number;
+    };
+    /** Line segment rendered below the last item. */
+    endLine?: {
+        show?: boolean;
+        feathered?: boolean;
+        color?: TimelineColor;
+        opacity?: number;
+    };
+    animated?: boolean;
+    /** Which animation plays on mount when `animated=true`. Default "slide-left". */
+    entryAnimation?: "slide-left" | "fade" | "slide-up" | "scale";
+    staggerDelay?: number;
+    className?: string;
+};
+export { TimelineBlockProps }
+export { TimelineBlockProps as TimelineBlockProps_alias_1 }
+
+/** Solid CSS color, a full `linear-gradient(...)` string, or a vertical-gradient shorthand. */
+declare type TimelineColor = string | {
+    from: string;
+    to: string;
+};
+export { TimelineColor }
+export { TimelineColor as TimelineColor_alias_1 }
+
+declare type TimelineItem = {
+    /** Small uppercase text rendered above the title when `labelPlacement="above"`. */
+    label?: string;
+    /** Bold heading (e.g. "Today", "In 6 Days"). */
+    title: string;
+    description?: string;
+    /** Lucide icon name. Placement controlled by block-level `iconPlacement`. */
+    icon?: string;
+    /** Node fill (badge) or ring (dot) color. */
+    color?: string;
+    /** Icon tint when rendered inside the badge. Defaults to white. */
+    iconColor?: string;
+    /** Wrap this item's content column (content icon, title, description) in a card. */
+    contentCard?: boolean;
+    /** Color of the outgoing line from this item down to the next. Ignored on the last item.
+     *  Falls back to block-level `lineColor`. */
+    lineColor?: TimelineColor;
+    /** Opacity of the outgoing line (0–1). Ignored on the last item. Falls back to block-level `lineOpacity`. */
+    lineOpacity?: number;
+};
+export { TimelineItem }
+export { TimelineItem as TimelineItem_alias_1 }
+
+export declare function toAppliedDiscountAnswer({ result, code, planVariable, }: {
+    result: Extract<DiscountCodeApplyResult, {
+        valid: true;
+    }>;
+    code: string;
+    planVariable?: string;
+}): AppliedDiscountAnswer;
+
+export declare function Tooltip({ ...props }: React_2.ComponentProps<typeof Tooltip_2.Root>): React_2.JSX.Element;
+
+export declare function TooltipContent({ className, sideOffset, children, ...props }: React_2.ComponentProps<typeof Tooltip_2.Content>): React_2.JSX.Element;
+
+export declare function TooltipProvider({ delayDuration, ...props }: React_2.ComponentProps<typeof Tooltip_2.Provider>): React_2.JSX.Element;
+
+export declare function TooltipTrigger({ ...props }: React_2.ComponentProps<typeof Tooltip_2.Trigger>): React_2.JSX.Element;
+
+/** Build the flattened answer payload stored in `answers[variable]` for a selected plan. */
+export declare function toSelectedPlanAnswer(plan: PricingPlan): SelectedPlanAnswer;
+
+declare type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+
+export declare function useCounter({ value, duration, decimals, startDelay, onTick, }: {
+    value: number;
+    duration?: number;
+    decimals?: number;
+    startDelay?: number;
+    onTick?: (rounded: number) => void;
+}): number;
+
+declare function useJourneyActions(): JourneyActions;
+export { useJourneyActions }
+export { useJourneyActions as useJourneyActions_alias_1 }
+
+export declare function useJourneyCapture(params: {
+    config: JourneyConfig | null;
+    capture: JourneyCaptureOption | null;
+    onEvent?: (event: JourneyEvent) => void;
+}): (event: JourneyEvent) => void;
+
+declare function useJourneyConfig({ apiKey, journeyId, baseUrl, config, capture, }: {
+    apiKey: string;
+    journeyId: string;
+    baseUrl?: string;
+    config?: JourneyConfig;
+    capture?: boolean;
+}): FetchState;
+export { useJourneyConfig }
+export { useJourneyConfig as useJourneyConfig_alias_1 }
+
+declare function useJourneyState(): JourneyState;
+export { useJourneyState }
+export { useJourneyState as useJourneyState_alias_1 }
+
+export declare function VideoBlock({ src, previewImage, autoplay, loop, muted, controls, aspectRatio, youtubeId, vimeoId, className, }: VideoBlockProps): JSX.Element;
+
+declare type VideoBlockProps = {
+    src?: string;
+    previewImage?: string;
+    autoplay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    controls?: boolean;
+    aspectRatio?: string;
+    youtubeId?: string;
+    vimeoId?: string;
+    className?: string;
+};
+export { VideoBlockProps }
+export { VideoBlockProps as VideoBlockProps_alias_1 }
+
+declare type WidgetStyle = {
+    layout?: "list" | "grid" | "segmented";
+    background?: string;
+    borderColor?: string;
+    borderRadius?: string;
+    hoverBackground?: string;
+    selectedBackground?: string;
+    selectedBorderColor?: string;
+    /** Gradient applied as a true rounded border on the selected card (uses CSS mask trick).
+     *  Pass any CSS background value: a `linear-gradient(...)` / `conic-gradient(...)` string,
+     *  or a `{ from, to, angle? }` shorthand. When unset, falls back to the
+     *  `--jy-selected-border-gradient` theme variable, then to `selectedBorderColor`. */
+    selectedBorderGradient?: GradientValue;
+    /** Border thickness in px when a gradient border is in play. Defaults to the
+     *  `--jy-selected-border-width` theme variable, then to 2. */
+    selectedBorderWidth?: number;
+    selectedBoxShadow?: string;
+    className?: string;
+    iconIndicator?: boolean;
+    iconBg?: string;
+    iconColor?: string;
+    selectedIconBg?: string;
+    selectedIconColor?: string;
+};
+export { WidgetStyle }
+export { WidgetStyle as WidgetStyle_alias_1 }
+
+export { }