motion-brew 0.0.0-stage → 0.1.1

package/dist/components/spending-meter/spending-meter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * SpendingMeter
+ *
+ * Trigger: in view, then hover. A spending card with a segmented bar. When it
+ * scrolls into view the pills fill one after another while the amount counts
+ * up from zero on odometer wheels with a light motion blur, all from one motion
+ * value. Each pill is an equal slice of the limit: hovering one dims
+ * the rest and rolls the number to what was spent in that slice, like the
+ * GoalGauge segments; arrow keys step through them and leaving rolls it back. Reaching the limit swaps the caption.
+ * Reduced motion shows the final state at once.
+ *
+ * Engine: motion/react (animate on a motion value, translate-only pill fills,
+ * odometer wheels, AnimatePresence for the caption).
+ */
+import * as React from "react";
+export interface SpendingMeterProps {
+    /** Amount spent so far. Default `1010`. */
+    value?: number;
+    /** Spending limit. Default `1800`. */
+    limit?: number;
+    /** Number of pills in the bar. Default `6`. */
+    pills?: number;
+    /** Fill color. Default `"#ff8f0f"`. */
+    color?: string;
+    /** Card title. Default `"Spending limit"`. */
+    title?: React.ReactNode;
+    /** Line under the title. Default `"1 to 12 Apr, 2026"`. */
+    subtitle?: React.ReactNode;
+    /** Currency for the amounts (ISO code). Default `"USD"`. */
+    currency?: string;
+    /** Locale for number formatting. Default `"en-US"`. */
+    locale?: string;
+    /** Length of the fill, in seconds. Default `1.4`. */
+    duration?: number;
+    /** Label for the header button. Pass `null` to hide it. Default `"View report"`. */
+    actionLabel?: React.ReactNode;
+    /** Called when the header button is pressed. */
+    onAction?: () => void;
+    className?: string;
+}
+export declare const SpendingMeter: React.ForwardRefExoticComponent<SpendingMeterProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/tab-bar/index.d.ts

@@ -0,0 +1 @@
+export { TabBar, type TabBarProps, type TabBarVariant, type TabIcon, type TabItem, } from "./tab-bar";

package/dist/components/tab-bar/tab-bar.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TabBar
+ *
+ * Trigger: press (plus keys and in view). A white mobile bottom navigation in
+ * three styles. Pill: the active tab grows into an ink pill that shows its
+ * label while the others stay icons, and the pill glides between tabs as the
+ * row reflows. Labels: icons over labels; the active one turns to ink, sits
+ * on a soft disc and has a small dot gliding beneath it. Action: four tabs
+ * around a raised ink button in the middle that springs and turns its plus a
+ * quarter when pressed. In every style a tap plays the tab's animated icon,
+ * dips the tab, sends a soft ripple out from under it, and badges pop in
+ * and out. When it scrolls into view the bar rises in and its tabs follow.
+ * Left and right arrows move between tabs. Reduced motion keeps every state
+ * without movement.
+ *
+ * Engine: motion/react (layoutId pill, dot and disc, a layout reflow, spring
+ * presses and ripples) with animated icons from lucide-animated (MIT),
+ * vendored in src/icons.
+ */
+import * as React from "react";
+export type TabIcon = "home" | "search" | "analytics" | "history" | "profile" | "bell" | "chat" | "explore" | "settings";
+export interface TabItem {
+    id: string;
+    label: string;
+    icon: TabIcon;
+    /** A small count on the icon. */
+    badge?: number;
+}
+export type TabBarVariant = "pill" | "labels" | "action";
+export interface TabBarProps {
+    /** Four or five tabs work best (four for the action style). */
+    tabs?: TabItem[];
+    /** Default `"pill"`. */
+    variant?: TabBarVariant;
+    /** The selected tab, when you control it. */
+    value?: string;
+    defaultValue?: string;
+    onChange?: (id: string) => void;
+    /** The middle button in the action style. */
+    actionLabel?: string;
+    onAction?: () => void;
+    className?: string;
+}
+export declare const TabBar: React.ForwardRefExoticComponent<TabBarProps & React.RefAttributes<HTMLElement>>;

package/dist/components/team-member-card/index.d.ts

@@ -0,0 +1 @@
+export { TeamMemberCard, type TeamMemberCardProps, type SocialLink, type SocialKind, } from "./team-member-card";

package/dist/components/team-member-card/team-member-card.d.ts

@@ -0,0 +1,66 @@
+/**
+ * TeamMemberCard
+ *
+ * Trigger: hover and press (plus in view). A white card for a person on the
+ * team. When it scrolls into view the card rises in, the photo sharpens out of
+ * a soft blur and settles from a slight zoom, and the name, role and details
+ * follow. White dithered pixels burn up from the bottom of the photo like
+ * fire, rising in flickering tongues that thin into finer specks, and die
+ * down to a softer glow while the card is hovered so the face shows more. At rest it shows the photo, name, role
+ * and Connect; hovering the card
+ * (or moving keyboard focus into it, or tapping it on touch) slides the
+ * details out from under the header on a soft spring, the location with live
+ * local time, the bio and the social links rising in one after another out of
+ * a blur, and folds them away again on leave. Over the photo it tilts toward
+ * the pointer with a soft shine and a little zoom. Connect rolls to Connected
+ * as its icon swaps. The social links are round buttons whose animated icons
+ * play on hover while a small ink label pops above them. Reduced motion keeps
+ * the states without movement.
+ *
+ * Engine: motion/react (staggered variants for the entrance, springs for the
+ * tilt and shine, AnimatePresence for the labels and the button roll) with
+ * animated icons from lucide-animated (MIT), vendored in src/icons.
+ */
+import * as React from "react";
+export type SocialKind = "x" | "linkedin" | "github" | "dribbble" | "email";
+export interface SocialLink {
+    kind: SocialKind;
+    href: string;
+    /** Label shown on hover and read to screen readers. Defaults to the network name. */
+    label?: string;
+}
+export interface TeamMemberCardProps {
+    name?: string;
+    role?: string;
+    photo?: string;
+    /** City shown with the local time. */
+    location?: string;
+    /** IANA time zone for the live local time, like `"Europe/Madrid"`. */
+    timeZone?: string;
+    /** One or two lines about them. */
+    bio?: string;
+    socials?: SocialLink[];
+    /** Dithered pixels burning up the photo like fire, dying down on hover. Default `true`. */
+    pixels?: boolean;
+    /** Colour of the pixels over the photo. Default `"#ffffff"`. */
+    pixelColor?: string;
+    /** Pixel grid cell in px. Default `6`. */
+    pixelSize?: number;
+    /** Pixel shape. Default `"square"`. */
+    pixelShape?: "square" | "circle" | "diamond";
+    /** Drift and shimmer speed; `2` is twice as fast. Default `1`. */
+    pixelSpeed?: number;
+    /** How high the flames reach up the photo. Default `1`. */
+    pixelArea?: number;
+    /** How heavy the flames are: higher fills them with bigger, bolder dots. Default `0.85`. */
+    pixelDensity?: number;
+    /** Overall strength of the pixels, 0 to 1. Default `1`. */
+    pixelOpacity?: number;
+    /** How much of the field stays while the card is hovered, 0 to 1. Default `0.6`. */
+    pixelHover?: number;
+    /** Start as connected. Default `false`. */
+    defaultConnected?: boolean;
+    onConnect?: (connected: boolean) => void;
+    className?: string;
+}
+export declare const TeamMemberCard: React.ForwardRefExoticComponent<TeamMemberCardProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/team-morph/index.d.ts

@@ -0,0 +1 @@
+export { TeamMorph, type TeamMorphProps, type TeamMember } from "./team-morph";

package/dist/components/team-morph/team-morph.d.ts

@@ -0,0 +1,38 @@
+/**
+ * TeamMorph
+ *
+ * Trigger: press, then hover. A presence pill that morphs into a team card. At
+ * rest it shows an overlapping stack of avatars, a "+n" chip and who is online;
+ * hovering lifts the pill, ripples the stack and sends the chevron through its circle. Pressing morphs the pill itself into a card: the
+ * shell flows from pill to rounded card while every avatar flies from its spot
+ * in the stack to its row in a calm two-group list (Online, Away), then names
+ * and roles cascade in. Close, Escape or a click outside morphs it back. Focus moves to
+ * the close button on open and returns to the pill on close.
+ *
+ * Engine: motion/react (one shell that stays mounted and resizes with a
+ * layout animation while its contents swap, shared layoutId avatars scoped by
+ * LayoutGroup, and staggered variants for the rows).
+ */
+import * as React from "react";
+export interface TeamMember {
+    name: string;
+    role: string;
+    /** Avatar color. Defaults through a soft built-in palette. */
+    color?: string;
+    /** Minutes since last seen; leave out when online. */
+    awayFor?: number;
+}
+export interface TeamMorphProps {
+    /** Team name. Default `"Design team"`. */
+    team?: string;
+    /** People, first ones are shown in the collapsed stack. Default five teammates. */
+    members?: TeamMember[];
+    /** Avatars shown in the collapsed stack. Default `3`. */
+    stack?: number;
+    /** Start expanded. Default `false`. */
+    defaultOpen?: boolean;
+    /** Called by the Invite button. Leave out to hide it. */
+    onInvite?: () => void;
+    className?: string;
+}
+export declare const TeamMorph: React.ForwardRefExoticComponent<TeamMorphProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/tilt-card/index.d.ts

@@ -0,0 +1 @@
+export { TiltCard, type TiltCardProps } from "./tilt-card";

package/dist/components/tilt-card/tilt-card.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TiltCard
+ *
+ * Trigger: hover. The card tilts in 3D toward the cursor on a spring, lifts a
+ * touch, and a glare highlight slides across the surface opposite the tilt.
+ * Leaving the card settles it flat. Touch and reduced-motion users get a flat card.
+ *
+ * Engine: motion/react (motion values + springs, no re-renders on move).
+ */
+import * as React from "react";
+import { type HTMLMotionProps, type SpringOptions } from "motion/react";
+export interface TiltCardProps extends Omit<HTMLMotionProps<"div">, "children"> {
+    children?: React.ReactNode;
+    /** Largest tilt on each axis, in degrees. Default `12`. */
+    maxTilt?: number;
+    /** Scale while hovered. Default `1.03`. */
+    hoverScale?: number;
+    /** Show the moving glare highlight. Default `true`. */
+    glare?: boolean;
+    /** Peak glare opacity, 0 to 1. Default `0.35`. */
+    glareOpacity?: number;
+    /** Camera distance for the 3D effect, in px. Lower is more dramatic. Default `800`. */
+    perspective?: number;
+    /** Spring for tilt and settle. Default `{ stiffness: 260, damping: 22, mass: 0.7 }`. */
+    spring?: SpringOptions;
+}
+export declare const TiltCard: React.ForwardRefExoticComponent<Omit<TiltCardProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/tilt-carousel/index.d.ts

@@ -0,0 +1 @@
+export { TiltCarousel, type TiltCarouselProps, type TiltCarouselItem, } from "./tilt-carousel";

package/dist/components/tilt-carousel/tilt-carousel.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TiltCarousel
+ *
+ * Trigger: drag (plus press and keys). A row of photo cards that moves on by
+ * itself: the one in the middle faces you square on and every card beside it
+ * turns away in 3D, shrinking, dimming and softening a little more the further
+ * out it sits. It starts gliding on its own and loops round forever, pausing
+ * while the pointer rests on it. Drag or flick the row and it follows your
+ * hand, then settles on the nearest card with a spring; clicking any card on
+ * the left steps one card left, on the right one card right, and the arrow
+ * keys step through it too. Reduced
+ * motion swaps the springs for plain moves and does not move on by itself.
+ *
+ * Engine: motion/react (one motion value for the position, per-card
+ * transforms derived from it, springs for the settle, a layoutId pill).
+ */
+import * as React from "react";
+export interface TiltCarouselItem {
+    src: string;
+    title: string;
+}
+export interface TiltCarouselProps {
+    /** Cards in the row. Default twelve photos. */
+    items?: TiltCarouselItem[];
+    /** Card width in px. Height follows at 4 by 5. Default `220`. */
+    cardWidth?: number;
+    /** How far the side cards turn away, in degrees. Default `40`. */
+    tilt?: number;
+    /** Perspective of the stage in px; lower is more dramatic. Default `900`. */
+    perspective?: number;
+    /** Size of the cards beside the middle one, 0.5 to 1. Default `0.86`. */
+    inactiveScale?: number;
+    /** How quickly the row glides and settles; `2` is twice as fast. Default `1`. */
+    speed?: number;
+    /** Move on by itself, pausing while the pointer is over it. Default `true`. */
+    autoplay?: boolean;
+    /** Seconds each card stays with autoplay on. Default `3`. */
+    delay?: number;
+    /** Accessible name. Default `"Photo carousel"`. */
+    label?: string;
+    className?: string;
+}
+export declare const TiltCarousel: React.ForwardRefExoticComponent<TiltCarouselProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/toast-stack/index.d.ts

@@ -0,0 +1 @@
+export { ToastStack, type ToastStackProps, type ToastStackHandle, type ToastItem, type ToastKind, } from "./toast-stack";

package/dist/components/toast-stack/toast-stack.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ToastStack
+ *
+ * Trigger: drag (plus hover and press). Notifications gather in a neat stack in
+ * the middle of their container instead of a screen corner: the newest sits in
+ * front and up to two older ones peek out behind it, smaller and quieter. A new
+ * toast rises in from below out of a blur and its icon plays (the check draws,
+ * the badge shakes, the bin lid lifts), while the rest step back. Hover or
+ * focus the stack and it fans open into a list, pausing every timer; leave and
+ * it folds back. Swipe a toast left or right and it tilts and fades with your
+ * finger, then flies off past a threshold (or springs back); the close button
+ * or Delete key works too. Toasts with a timer show a thin line that runs down
+ * at their foot. A row of pills below adds sample toasts, and Clear all sweeps
+ * them away one after another. Reduced motion keeps the states without the
+ * movement.
+ *
+ * Engine: motion/react (springs for the stack positions and heights, drag with
+ * transforms for the swipe, AnimatePresence for enter and exit, a motion value
+ * for each timer line).
+ */
+import * as React from "react";
+export type ToastKind = "success" | "warning" | "error" | "info";
+export interface ToastItem {
+    id?: string;
+    kind: ToastKind;
+    title: string;
+    description?: string;
+    /** A button in the toast, such as Undo. The toast closes after it runs. */
+    action?: {
+        label: string;
+        onClick?: () => void;
+    };
+    /** Milliseconds before it leaves on its own; 0 keeps it. Default: the stack's `duration`. */
+    duration?: number;
+}
+export interface ToastStackHandle {
+    /** Add a toast to the front. Returns its id. */
+    push: (toast: ToastItem) => string;
+    dismiss: (id: string) => void;
+    clear: () => void;
+}
+export interface ToastStackProps {
+    /** Toasts shown at the start, oldest first. They stay until dismissed. */
+    initial?: ToastItem[];
+    /** Default time on screen for new toasts, in ms; 0 keeps them. Default `6000`. */
+    duration?: number;
+    /** How many toasts the folded stack shows. Default `3`. */
+    visible?: number;
+    /** Show the row of sample buttons under the stack. Default `true`. */
+    triggers?: boolean;
+    /** Called when a toast leaves, for any reason. */
+    onDismiss?: (toast: ToastItem & {
+        id: string;
+    }) => void;
+    className?: string;
+}
+export declare const ToastStack: React.ForwardRefExoticComponent<ToastStackProps & React.RefAttributes<ToastStackHandle>>;

package/dist/components/usage-ring/index.d.ts

@@ -0,0 +1 @@
+export { UsageRing, type UsageRingProps } from "./usage-ring";

package/dist/components/usage-ring/usage-ring.d.ts

@@ -0,0 +1,40 @@
+/**
+ * UsageRing
+ *
+ * Trigger: in view, then press and hover. A white card for plan usage: a
+ * ring made of short segments around a big percent. When it scrolls into
+ * view the segments light up one after another, clockwise, while the percent
+ * and the caption's amount count up on odometer wheels. The library's
+ * PillTabs under the ring switch the resource (API, Storage, Seats): its white
+ * pill stretches across to the tab, the segments glide to the new share of
+ * the plan and the numbers roll to match. Hovering the ring lifts each lit
+ * segment a hair outward in a wave. Reduced motion shows the final state at
+ * once.
+ *
+ * Engine: motion/react (counting motion values drive the segments and the
+ * odometer numbers, springs for each segment) with PillTabs for the metric
+ * switch.
+ */
+import * as React from "react";
+export interface UsageMetric {
+    label: string;
+    value: number;
+    goal: number;
+    unit: string;
+}
+export interface UsageRingProps {
+    /** Title. Default `"Plan usage"`. */
+    title?: string;
+    /** The resources, one per tab. Default API calls, storage and seats. */
+    metrics?: UsageMetric[];
+    /** Segments around the ring. Default `20`. */
+    segments?: number;
+    /**
+     * Hues the ring walks between on the colour wheel, in degrees, from empty to
+     * the limit. Default `[265, 385]`: indigo through violet and magenta to coral
+     * red (385 is 25 once round the wheel).
+     */
+    hues?: [number, number];
+    className?: string;
+}
+export declare const UsageRing: React.ForwardRefExoticComponent<UsageRingProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/verify-flow/index.d.ts

@@ -0,0 +1 @@
+export { VerifyFlow, type VerifyFlowProps, type VerifyStage } from "./verify-flow";

package/dist/components/verify-flow/verify-flow.d.ts

@@ -0,0 +1,49 @@
+/**
+ * VerifyFlow
+ *
+ * Trigger: timeline. A verification card in three stages: connect, check,
+ * verified. A segmented progress bar fills as it goes, with a rolling timer
+ * underneath. First a provider row waits for sign-in; its button shimmers until
+ * pressed. Then the checks run in a soft list: a white highlight slides down to
+ * whichever check is running, each row's status rolls from Queued to Checking to
+ * Passed, and the header icon spins. Finally the header icon turns into a check
+ * with a ring pulse, a green seal spins in with a burst of sparks to show the
+ * account connected, and the Continue button counts down
+ * with a ring that drains inside it. The card's height glides between stages.
+ * Runs as a self-playing demo, or drive it with `stage` and `completed`. Status
+ * changes are announced politely. Reduced motion swaps states without travel.
+ *
+ * Engine: motion/react + gsap (Motion for the height glide, sliding highlight,
+ * bar fills, rolling text and press feedback; GSAP via @gsap/react for the
+ * button shimmer, spinners, check draws, ring pulse and the countdown ring).
+ */
+import * as React from "react";
+export type VerifyStage = "waiting" | "checking" | "done";
+export interface VerifyFlowProps {
+    /** Current stage. Leave unset to run the self-playing demo. */
+    stage?: VerifyStage;
+    /** How many checks have passed (the next one is running). Used with `stage="checking"`. */
+    completed?: number;
+    /** Checks to run. Default three. */
+    checks?: string[];
+    /** Card title. Default `"Verify your account"`. */
+    title?: string;
+    /** Provider shown on the sign-in row. Default `"GitHub"`. */
+    provider?: string;
+    /** Provider icon. Default the GitHub mark. */
+    providerIcon?: React.ReactNode;
+    /** Called when the sign-in button is pressed. */
+    onSignIn?: () => void;
+    /** Where Continue goes, named on the button. Default `"Acme"`. */
+    destination?: string;
+    /** Seconds before `onContinue` fires on its own. Default `5`. */
+    redirectSeconds?: number;
+    /** Called from Continue, or when the countdown runs out. */
+    onContinue?: () => void;
+    /** Demo only: start over after finishing. Default `false`. */
+    loop?: boolean;
+    /** Color for progress and passed checks. Default a calm green. */
+    accent?: string;
+    className?: string;
+}
+export declare const VerifyFlow: React.ForwardRefExoticComponent<VerifyFlowProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/voice-prompt/index.d.ts

@@ -0,0 +1 @@
+export { VoicePrompt, type VoicePromptProps, type VoicePromptMode } from "./voice-prompt";

package/dist/components/voice-prompt/voice-prompt.d.ts

@@ -0,0 +1,55 @@
+/**
+ * VoicePrompt
+ *
+ * Trigger: press. A composer for an AI assistant that you can talk to. At rest
+ * a low tide of colour breathes along the bottom of the card. Press the mic and
+ * the card opens up while the tide rises: a soft glow that deepens from a lit
+ * crest to a dark core, with slow noise swirling through it, a thin light
+ * running along the crest and a light film grain. The crest is shaped by your
+ * voice: a wide lobe swells with low tones, twin lobes with the middle and a
+ * fine ripple with the highs. Loud moments overdrive it: rows shear, strips
+ * tear and the colour channels split apart, like a signal pushed too hard.
+ * With microphone access it follows your real voice; without it, a made-up
+ * voice drives it. The words it hears arrive one by one at the top of the
+ * card, each sharpening out of a blur, in a two line teleprompter window:
+ * as you keep talking the text glides up and the oldest line fades away
+ * through the top. A faint shimmer runs round the card's outline. Press the mic again (now a check) to
+ * keep them, ready to send, or the cross to throw them away. A mode picker
+ * opens upward with a sliding highlight, and the send button wakes once there
+ * is text. Reduced motion keeps every state but holds the glow still.
+ *
+ * Engine: GSAP (a ticker feeding the voice into a WebGL fragment shader,
+ * tweens for the listening energy, quick setters for the mic's level ring and
+ * a blur in for each heard word), with motion/react for the height glide and
+ * the menu.
+ */
+import * as React from "react";
+export interface VoicePromptMode {
+    id: string;
+    label: string;
+    /** A short line under the name in the menu. */
+    hint: string;
+}
+export interface VoicePromptProps {
+    /** Placeholder for the empty field. */
+    placeholder?: string;
+    /** Modes in the picker. Default three. */
+    modes?: VoicePromptMode[];
+    /** Four colours of the glow: its deep core, body, lit crest and outer bloom. Default dusk. */
+    colors?: string[];
+    /** Card theme. Default `"light"`. */
+    theme?: "light" | "dark";
+    /** Ask for the microphone so the wave follows a real voice. Default `true`. */
+    microphone?: boolean;
+    /** What the demo "hears", revealed word by word while listening. */
+    script?: string;
+    /** Called on send. */
+    onSubmit?: (prompt: {
+        text: string;
+        mode: string;
+    }) => void;
+    /** Called by the plus button. */
+    onAttach?: () => void;
+    className?: string;
+}
+export declare const VoicePrompt: React.ForwardRefExoticComponent<VoicePromptProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/wallet-card/index.d.ts

@@ -0,0 +1 @@
+export { WalletCard, type WalletCardProps, type WalletCurrency, type WalletAction } from "./wallet-card";

package/dist/components/wallet-card/wallet-card.d.ts

@@ -0,0 +1,54 @@
+/**
+ * WalletCard
+ *
+ * Trigger: in view, then press and hover. A balance card with a currency switch
+ * and quick actions. The balance counts up from zero on odometer wheels when the
+ * card comes into view (like the chart cards) while the action circles pop in.
+ * Picking another currency from the pill rolls the balance on odometer
+ * wheels (with a light motion blur) to the converted amount in that currency's
+ * own format. Each icon enters from its action's direction, then plays its
+ * own animation when its circle is hovered (animated icons from
+ * lucide-animated, MIT, in src/icons).
+ * Pressing squashes the circle and ripples a ring. "More features" expands to
+ * reveal more actions in a cascade. Reduced motion keeps every change instant.
+ *
+ * Engine: motion/react (odometer wheels on a motion value, a layoutId highlight
+ * in the currency list, animated icons, AnimatePresence for the list and panel).
+ */
+import * as React from "react";
+export interface WalletCurrency {
+    /** ISO code, e.g. "EUR". */
+    code: string;
+    /** Flag or symbol shown in the pill. */
+    flag: string;
+    /** Full name in the list. */
+    name: string;
+    /** Units of this currency per one unit of the base balance. */
+    rate: number;
+    /** Locale used to format it. Default `"en-US"`. */
+    locale?: string;
+    /** Decimal places to show. Default the currency's usual digits. */
+    digits?: number;
+}
+export interface WalletAction {
+    label: string;
+    /** Icon from the built-in set. */
+    icon: "transfer" | "topup" | "exchange" | "paylater" | "bills" | "savings" | "mobile" | "invest";
+    onSelect?: () => void;
+}
+export interface WalletCardProps {
+    /** Balance in the first currency's units. Default `3840.52`. */
+    balance?: number;
+    /** Currencies in the switch; the first is the base the balance is given in. */
+    currencies?: WalletCurrency[];
+    /** Actions always shown. Default transfer, top up, exchange, pay later. */
+    actions?: WalletAction[];
+    /** Extra actions revealed by "More features". Pass an empty list to hide the row. */
+    moreActions?: WalletAction[];
+    /** Action circle color. Default `"#2a2e3c"`. */
+    color?: string;
+    /** Length of the count-up and each currency roll, in seconds. Default `1.4`. */
+    duration?: number;
+    className?: string;
+}
+export declare const WalletCard: React.ForwardRefExoticComponent<WalletCardProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/wave-text/index.d.ts

@@ -0,0 +1 @@
+export { WaveText, type WaveTextProps } from "./wave-text";

package/dist/components/wave-text/wave-text.d.ts

@@ -0,0 +1,27 @@
+/**
+ * WaveText
+ *
+ * Trigger: hover. A heading whose words warp like liquid when touched. Each
+ * word carries its own SVG filter: fractal noise drives a displacement map that
+ * bends the glyphs into flowing bands. Hovering a word ramps the displacement
+ * up and keeps the noise drifting, so the warp flows rather than freezing;
+ * leaving eases it back to crisp type. The filter is only attached while a word
+ * is warping, so idle text costs nothing. Touch taps a word to ripple it once.
+ * Reduced motion leaves the type still.
+ *
+ * Engine: motion/react (motion values animated on enter and leave, written
+ * straight into the SVG filter attributes, no re-renders per frame).
+ */
+import * as React from "react";
+export interface WaveTextProps {
+    /** The heading text; each word warps on its own. Default `"Bend the rules"`. */
+    text?: string;
+    /** Element to render. Default `"h2"`. */
+    as?: "h1" | "h2" | "h3" | "p" | "div";
+    /** Peak displacement in px. Higher bends harder. Default `40`. */
+    strength?: number;
+    /** Seconds for one full drift of the wave while hovered. Default `1.8`. */
+    speed?: number;
+    className?: string;
+}
+export declare const WaveText: React.ForwardRefExoticComponent<WaveTextProps & React.RefAttributes<HTMLElement>>;

package/dist/contact-card.d.ts

@@ -0,0 +1 @@
+export * from "./components/contact-card/index";

package/dist/contact-card.js

@@ -0,0 +1,12 @@
+"use client";
+import {
+  ContactCard
+} from "./chunk-2NRXP4HM.js";
+import "./chunk-ADXWPWJR.js";
+import "./chunk-JJEWOQYQ.js";
+import "./chunk-M22UY764.js";
+import "./chunk-JHT6RCGY.js";
+import "./chunk-2TQSHVXA.js";
+export {
+  ContactCard
+};

package/dist/context-menu.d.ts

@@ -0,0 +1 @@
+export * from "./components/context-menu/index";

package/dist/context-menu.js

@@ -0,0 +1,17 @@
+"use client";
+import {
+  ContextMenu
+} from "./chunk-T2TSMDP3.js";
+import "./chunk-VIR5NV5W.js";
+import "./chunk-MUDKP3LK.js";
+import "./chunk-XH6YNONO.js";
+import "./chunk-JFTD3YAL.js";
+import "./chunk-M22UY764.js";
+import "./chunk-BN4MA5UY.js";
+import "./chunk-YGONLKWH.js";
+import "./chunk-IKM7EEYN.js";
+import "./chunk-JHT6RCGY.js";
+import "./chunk-2TQSHVXA.js";
+export {
+  ContextMenu
+};

package/dist/contour-feature-card.d.ts

@@ -0,0 +1 @@
+export * from "./components/contour-feature-card/index";

package/dist/contour-feature-card.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  ContourFeatureCard
+} from "./chunk-TNLY4CSA.js";
+import "./chunk-WOR2GMMN.js";
+import "./chunk-2TQSHVXA.js";
+export {
+  ContourFeatureCard
+};

package/dist/contour-lines.d.ts

@@ -0,0 +1 @@
+export * from "./components/contour-lines/index";

package/dist/contour-lines.js

@@ -0,0 +1,8 @@
+"use client";
+import {
+  ContourLines
+} from "./chunk-6JQY7AX5.js";
+import "./chunk-2TQSHVXA.js";
+export {
+  ContourLines
+};