@yewdiel21/motion-kit 0.0.0-stage → 0.9.0

package/dist/react/index.d.ts

@@ -0,0 +1,476 @@
+import * as react from 'react';
+import { useLayoutEffect, RefObject, DependencyList, ReactNode, CSSProperties, Component, ButtonHTMLAttributes, DialogHTMLAttributes, HTMLAttributes, MutableRefObject, ContextType, TextareaHTMLAttributes, MouseEvent } from 'react';
+import { I as Instance } from '../types-BkS_raL8.js';
+import { aE as SpringCardsOptions, Q as CurvedCarouselOptions, C as CurvedCarouselInstance, ai as PileOptions, aM as WordsOptions, aL as WordsInstance, a2 as FlowOptions, a1 as FlowInstance, ak as PopOptions, aj as PopInstance, $ as FitTextOptions, _ as FitTextInstance, aG as StretchFooterOptions, am as RadialMenuOptions, al as RadialMenuInstance, aI as TabsOptions, aH as TabsInstance, P as CounterOptions, O as CounterInstance, at as RevealRecipeOptions, as as RevealInstance, ao as ReflowOptions, an as ReflowInstance, ax as SlotTextOptions, aw as SlotTextInstance, aC as SortableOptions, aA as SortableInstance, ad as MaskTextOptions, ac as MaskTextInstance, K as CascadeOptions, J as CascadeInstance, aK as TextRollOptions, aJ as TextRollInstance, a9 as LettersOptions, a8 as LettersInstance, af as ParallaxOptions, ae as ParallaxInstance, S as DepthGridOptions, R as DepthGridInstance, a5 as FrameZoomOptions, a4 as FrameZoomInstance, N as ContrastOptions, L as ContrastInstance, ab as MarqueeOptions, aa as MarqueeInstance, I as CardDockOptions, H as CardDockInstance, az as SnapStripOptions, ay as SnapStripInstance, Z as FillTextOptions, Y as FillTextInstance, T as TicketMenuOptions, a7 as InfiniteReelOptions, a6 as InfiniteReelInstance, ar as RepelBentoOptions, aq as RepelBentoInstance, av as RotatorOptions, au as RotatorInstance, X as DragRulerOptions, W as DragRulerInstance, V as DockPillOptions, U as DockPillInstance } from '../reduced-BM4Ls0g5.js';
+export { M as MK_HEAD_SCRIPT, ah as PileLayer, ap as ReorderDetail, aS as moveItem, aT as pileLayers, aU as pileStyle } from '../reduced-BM4Ls0g5.js';
+import { M as MenuInstance, b as DialogOptions, D as DialogInstance } from '../reveal-WFUWDrei.js';
+import { LiquidBlendOptions, ShaderEffectInstance, MatcapOptions, ShaderGrainOptions, ShaderBlurOptions, ParticleHeroOptions, ParticleHeroInstance } from '../gl/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { T as ThemeState, s as setTheme, a as setMode, I as InitThemeOptions, b as ThemeMode } from '../theme-BFMoCzi6.js';
+export { M as MK_THEME_HEAD_SCRIPT, t as themeHeadScript } from '../theme-BFMoCzi6.js';
+import { n as ThemePickerOptions, s as ToasterLabels, e as ChatLabels, C as ChatInstance, v as capturePending, b as ChatRole, c as NavStyle, h as CursorVariant, g as CursorOptions, i as IslandOptions, I as IslandInstance } from '../store-Bqy_obnD.js';
+export { j as NAV_STYLES, o as ToastAction, q as ToastOptions, r as ToastTone, x as clearToasts, F as dismissToast, t as toast } from '../store-Bqy_obnD.js';
+import { C as CapturedLayout } from '../confetti-BSX1CLLV.js';
+export { A as ANIMATIONS, b as AnimationName, d as ConfettiOptions, e as animate, g as confetti, l as leave } from '../confetti-BSX1CLLV.js';
+import 'gsap/SplitText';
+import 'gsap/Flip';
+
+/** useLayoutEffect in the browser (no flash), useEffect during SSR (no warning). */
+declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+/**
+ * Create a recipe on `ref.current` after mount and destroy it on unmount or when
+ * `deps` change. Returns a ref holding the live instance (controls like `next()`).
+ */
+declare function useRecipe<I extends Instance, O>(ref: RefObject<HTMLElement | null>, factory: (el: HTMLElement | null, options?: O) => I, options?: O, deps?: DependencyList): RefObject<I | null>;
+/** Keep the latest callback in a ref so recipes do not restart on every render. */
+declare function useLatest<T>(value: T): RefObject<T>;
+
+declare const useSpringCards: (ref: RefObject<HTMLElement | null>, options?: SpringCardsOptions, deps?: DependencyList) => RefObject<Instance | null>;
+
+declare function useCurvedCarousel(ref: RefObject<HTMLElement | null>, options?: CurvedCarouselOptions, deps?: DependencyList): RefObject<CurvedCarouselInstance | null>;
+
+declare const usePile: (ref: RefObject<HTMLElement | null>, options?: PileOptions, deps?: DependencyList) => RefObject<Instance | null>;
+
+declare const useWords: (ref: RefObject<HTMLElement | null>, options?: WordsOptions, deps?: DependencyList) => RefObject<WordsInstance | null>;
+
+declare const useFlow: (ref: RefObject<HTMLElement | null>, options?: FlowOptions, deps?: DependencyList) => RefObject<FlowInstance | null>;
+
+declare const usePop: (ref: RefObject<HTMLElement | null>, options?: PopOptions, deps?: DependencyList) => RefObject<PopInstance | null>;
+
+declare const useFitText: (ref: RefObject<HTMLElement | null>, options?: FitTextOptions, deps?: DependencyList) => RefObject<FitTextInstance | null>;
+
+interface UseStretchFooterOptions extends Omit<StretchFooterOptions, 'phantom' | 'title'> {
+    phantomRef?: RefObject<HTMLElement | null>;
+    titleRef?: RefObject<HTMLElement | null>;
+}
+declare function useStretchFooter(ref: RefObject<HTMLElement | null>, options?: UseStretchFooterOptions, deps?: DependencyList): RefObject<Instance | null>;
+
+declare function useRadialMenu(ref: RefObject<HTMLElement | null>, options?: RadialMenuOptions, deps?: DependencyList): RefObject<RadialMenuInstance | null>;
+
+declare function useTabs(ref: RefObject<HTMLElement | null>, options?: TabsOptions, deps?: DependencyList): RefObject<TabsInstance | null>;
+
+declare const useCounter: (ref: RefObject<HTMLElement | null>, options?: CounterOptions, deps?: DependencyList) => RefObject<CounterInstance | null>;
+
+declare const useDetails: (ref: RefObject<HTMLElement | null>, deps?: DependencyList) => RefObject<Instance | null>;
+
+declare const useReveal: (ref: RefObject<HTMLElement | null>, options?: RevealRecipeOptions, deps?: DependencyList) => RefObject<RevealInstance | null>;
+
+/** Call `.current.capture()` before the state change and `.current.play()` in a layout effect after it. */
+declare const useReflow: (ref: RefObject<HTMLElement | null>, options?: ReflowOptions, deps?: DependencyList) => RefObject<ReflowInstance | null>;
+
+/**
+ * Rolls `text` into `ref` whenever it changes. The element must render no
+ * children of its own: the recipe writes the letters (see `<SlotText>`).
+ */
+declare function useSlotText(ref: RefObject<HTMLElement | null>, text: string, options?: Omit<SlotTextOptions, 'text'>): RefObject<SlotTextInstance | null>;
+
+/**
+ * Drag to reorder a list React renders: answer `onReorder` by updating your state
+ * (React moves the DOM; the engine waits for it and lands the item). `mutate` is off.
+ */
+declare function useSortable(ref: RefObject<HTMLElement | null>, options?: SortableOptions, deps?: DependencyList): RefObject<SortableInstance | null>;
+
+/** Masked lines / words / letters rising into view (OFFFICE). */
+declare const useMaskText: (ref: RefObject<HTMLElement | null>, options?: MaskTextOptions, deps?: DependencyList) => RefObject<MaskTextInstance | null>;
+
+/** Siena's reveal group: rules, fades and rises one after another. */
+declare const useCascade: (ref: RefObject<HTMLElement | null>, options?: CascadeOptions, deps?: DependencyList) => RefObject<CascadeInstance | null>;
+
+/** Siena's slot title. `.current.play()` spins it. */
+declare const useTextRoll: (ref: RefObject<HTMLElement | null>, options?: TextRollOptions, deps?: DependencyList) => RefObject<TextRollInstance | null>;
+
+/** Dousan's hero letters (scale on hover or pastel blink). */
+declare const useLetters: (ref: RefObject<HTMLElement | null>, options?: LettersOptions, deps?: DependencyList) => RefObject<LettersInstance | null>;
+
+/** Siena's photo parallax inside its frame. */
+declare const useParallax: (ref: RefObject<HTMLElement | null>, options?: ParallaxOptions, deps?: DependencyList) => RefObject<ParallaxInstance | null>;
+
+/** Siena's grid gathering from depth as it scrolls. */
+declare const useDepthGrid: (ref: RefObject<HTMLElement | null>, options?: DepthGridOptions, deps?: DependencyList) => RefObject<DepthGridInstance | null>;
+
+/** Siena's video mask: frame and picture scale in opposite directions. */
+declare const useFrameZoom: (ref: RefObject<HTMLElement | null>, options?: FrameZoomOptions, deps?: DependencyList) => RefObject<FrameZoomInstance | null>;
+
+/** Siena's header contrast from the section under it. */
+declare const useContrast: (ref: RefObject<HTMLElement | null>, options?: ContrastOptions, deps?: DependencyList) => RefObject<ContrastInstance | null>;
+
+/** Siena's seamless marquee. */
+declare const useMarquee: (ref: RefObject<HTMLElement | null>, options?: MarqueeOptions, deps?: DependencyList) => RefObject<MarqueeInstance | null>;
+
+/** iyo.ai's product dock (stacked glass cards that spread on hover). */
+declare const useCardDock: (ref: RefObject<HTMLElement | null>, options?: CardDockOptions, deps?: DependencyList) => RefObject<CardDockInstance | null>;
+
+/** iyo.ai's phone cards: an autoplaying scroll-snap strip. */
+declare const useSnapStrip: (ref: RefObject<HTMLElement | null>, options?: SnapStripOptions, deps?: DependencyList) => RefObject<SnapStripInstance | null>;
+
+/** iyo.ai's fill-text: letters fill in as the text scrolls up. */
+declare const useFillText: (ref: RefObject<HTMLElement | null>, options?: FillTextOptions, deps?: DependencyList) => RefObject<FillTextInstance | null>;
+
+declare function useTicketMenu(ref: RefObject<HTMLElement | null>, options?: TicketMenuOptions, deps?: DependencyList): RefObject<MenuInstance | null>;
+
+declare const useInfiniteReel: (ref: RefObject<HTMLElement | null>, options?: InfiniteReelOptions, deps?: DependencyList) => RefObject<InfiniteReelInstance | null>;
+
+declare const useRepelBento: (ref: RefObject<HTMLElement | null>, options?: RepelBentoOptions, deps?: DependencyList) => RefObject<RepelBentoInstance | null>;
+
+declare function useRotator(ref: RefObject<HTMLElement | null>, options?: RotatorOptions, deps?: DependencyList): RefObject<RotatorInstance | null>;
+
+declare function useDragRuler(ref: RefObject<HTMLElement | null>, options?: DragRulerOptions, deps?: DependencyList): RefObject<DragRulerInstance | null>;
+
+declare function useDockPill(ref: RefObject<HTMLElement | null>, options?: DockPillOptions, deps?: DependencyList): RefObject<DockPillInstance | null>;
+
+declare const useLiquidBlend: (ref: RefObject<HTMLElement | null>, options?: LiquidBlendOptions, deps?: DependencyList) => RefObject<ShaderEffectInstance | null>;
+
+declare const useMatcap: (ref: RefObject<HTMLElement | null>, options?: MatcapOptions, deps?: DependencyList) => RefObject<ShaderEffectInstance | null>;
+
+declare const useShaderGrain: (ref: RefObject<HTMLElement | null>, options?: ShaderGrainOptions, deps?: DependencyList) => RefObject<ShaderEffectInstance | null>;
+
+declare const useShaderBlur: (ref: RefObject<HTMLElement | null>, options?: ShaderBlurOptions, deps?: DependencyList) => RefObject<ShaderEffectInstance | null>;
+
+/** iyo.ai's particle hero (WebGL2, Canvas2D fallback). The canvas joins the ref's element. */
+declare const useParticleHero: (ref: RefObject<HTMLElement | null>, options?: ParticleHeroOptions, deps?: DependencyList) => RefObject<ParticleHeroInstance | null>;
+
+interface ThemeContextValue extends ThemeState {
+    setTheme: typeof setTheme;
+    setMode: typeof setMode;
+}
+interface ThemeProviderProps {
+    children?: ReactNode;
+    defaultTheme?: InitThemeOptions['default'];
+    mode?: ThemeMode;
+    storageKey?: string;
+}
+/**
+ * Applies the stored (or default) theme on mount and shares it. Add
+ * MK_THEME_HEAD_SCRIPT to <head> as well, so the first paint already has it.
+ */
+declare function ThemeProvider({ children, defaultTheme, mode, storageKey }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useTheme(): ThemeContextValue;
+
+interface ThemePickerProps extends ThemePickerOptions {
+    className?: string;
+    style?: CSSProperties;
+    /** Skip the base class (style it yourself). */
+    unstyled?: boolean;
+}
+/** Stepbro's theme picker. Wrap the app in <ThemeProvider> to read the choice. */
+declare function ThemePicker({ className, style, unstyled, themes, showHidden, labels, onChange }: ThemePickerProps): react_jsx_runtime.JSX.Element;
+
+interface SlotTextProps extends Omit<SlotTextOptions, 'text' | 'accessibleCopy'> {
+    text: string;
+    className?: string;
+}
+/**
+ * Text whose letters roll when it changes (Stepbro's SlotText). The server
+ * renders the text itself; React never reconciles the letters (they belong to
+ * the recipe), and screen readers read the plain copy.
+ */
+declare function SlotText({ text, className, direction, duration, stagger, exitOffset, colorFade, maxTilt }: SlotTextProps): react_jsx_runtime.JSX.Element;
+
+interface AnimatedNumberProps {
+    value: number;
+    /** How the shown value is written. Default: whole numbers. */
+    format?: (shown: number) => string;
+    /** Seconds. Default 0.6 (Stepbro's numberSoft); prices use 0.7. */
+    duration?: number;
+}
+/** A number that counts to each new value from the one shown (Stepbro's AnimatedNumber). */
+declare function AnimatedNumber({ value, format, duration }: AnimatedNumberProps): react_jsx_runtime.JSX.Element;
+
+interface FlipGroupProps {
+    /** The list element. */
+    root: RefObject<HTMLElement | null>;
+    /** Items inside it; they need a stable `data-flip-id`. */
+    selector?: string;
+    /** Changes whenever the layout should animate (order, filter, grouping): e.g. the ids joined. */
+    signature: string;
+    children?: ReactNode;
+}
+/**
+ * Plays Stepbro's layout reflow when `signature` changes: the layout is
+ * measured just before React commits and the items travel from there. A class
+ * component, because only `getSnapshotBeforeUpdate` reads the DOM before the commit.
+ */
+declare class FlipGroup extends Component<FlipGroupProps> {
+    private flip;
+    getSnapshotBeforeUpdate(previous: Readonly<FlipGroupProps>): CapturedLayout | null;
+    componentDidUpdate(_previous: unknown, _state: unknown, before: CapturedLayout | null): void;
+    componentWillUnmount(): void;
+    render(): ReactNode;
+}
+
+declare const ICON_PATHS: {
+    readonly close: "M6 6l12 12M18 6L6 18";
+    readonly expand: "M14 4h6v6M10 20H4v-6M20 4l-7 7M4 20l7-7";
+    readonly shrink: "M4 14h6v6M20 10h-6V4M10 14l-7 7M14 10l7-7";
+    readonly check: "M5 12.5l4.5 4.5L19 7.5";
+    readonly alert: "M12 8v5M12 16.5v.01M10.3 3.9L2.6 17.3a2 2 0 001.7 3h15.4a2 2 0 001.7-3L13.7 3.9a2 2 0 00-3.4 0z";
+    readonly info: "M12 11v6M12 7.5v.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z";
+    readonly send: "M12 19V5M5.5 11.5L12 5l6.5 6.5";
+    readonly mic: "M12 3a3 3 0 00-3 3v6a3 3 0 006 0V6a3 3 0 00-3-3zM5.5 11a6.5 6.5 0 0013 0M12 17.5V21";
+    readonly sparkle: "M12 3l1.9 5.1L19 10l-5.1 1.9L12 17l-1.9-5.1L5 10l5.1-1.9z";
+    readonly grip: "M9 6h.01M15 6h.01M9 12h.01M15 12h.01M9 18h.01M15 18h.01";
+};
+type IconName = keyof typeof ICON_PATHS;
+
+/** The same stroke icons the vanilla components use (aria-hidden). */
+declare function MkIcon({ name, size }: {
+    name: IconName;
+    size?: number;
+}): react_jsx_runtime.JSX.Element;
+
+type SurfaceOptions = Omit<DialogOptions, 'onOpen' | 'onClose' | 'triggers'>;
+interface SurfaceRootProps extends SurfaceOptions {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+declare function Root$3(props: SurfaceRootProps): react_jsx_runtime.JSX.Element;
+/** A button that opens the dialog and is the shape it grows from. */
+declare function Trigger$1({ onClick, children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): react_jsx_runtime.JSX.Element;
+interface DialogContentProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, 'open'> {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Skip the base class (style it yourself). */
+    unstyled?: boolean;
+}
+declare function Content$1({ size, unstyled, className, children, ...props }: DialogContentProps): react_jsx_runtime.JSX.Element;
+declare function Close({ children, label, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    label?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function Handle({ children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): react_jsx_runtime.JSX.Element;
+/**
+ * Stepbro's dialog for React:
+ * <Dialog.Root><Dialog.Trigger>Crear</Dialog.Trigger><Dialog.Content>
+ *   <Dialog.Header><Dialog.Title>…</Dialog.Title><Dialog.Close /></Dialog.Header>
+ *   <Dialog.Body>…</Dialog.Body><Dialog.Footer>…</Dialog.Footer>
+ * </Dialog.Content></Dialog.Root>
+ */
+declare const Dialog: {
+    Root: typeof Root$3;
+    Trigger: typeof Trigger$1;
+    Content: typeof Content$1;
+    Header: ({ children, ...props }: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    Title: ({ children, ...props }: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    Description: ({ children, ...props }: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    Actions: ({ children, ...props }: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    Body: ({ children, ...props }: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    Footer: ({ children, ...props }: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    Close: typeof Close;
+    Handle: typeof Handle;
+};
+/** The dialog instance of the surrounding <Dialog.Root> (open, close, float…). */
+declare function useDialog(): {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    instance: MutableRefObject<DialogInstance | null>;
+};
+
+interface MenuRootProps extends Omit<SurfaceRootProps, 'placement' | 'backdrop' | 'drag' | 'autoResize'> {
+    ticket?: boolean;
+    onSelect?: (value: string, item: HTMLElement) => void;
+    closeOnSelect?: boolean;
+    children?: ReactNode;
+}
+declare function Root$2({ onSelect, closeOnSelect, ticket, children, ...props }: MenuRootProps): react_jsx_runtime.JSX.Element;
+declare function Trigger({ onClick, children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): react_jsx_runtime.JSX.Element;
+declare function Content({ className, children, ...props }: Omit<DialogHTMLAttributes<HTMLDialogElement>, 'open'>): react_jsx_runtime.JSX.Element;
+declare function Item({ value, children, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    value?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function Separator(): react_jsx_runtime.JSX.Element;
+/** Stepbro's options menu: <Menu.Root onSelect><Menu.Trigger/><Menu.Content><Menu.Item value/>…</Menu.Content></Menu.Root>. */
+declare const Menu: {
+    Root: typeof Root$2;
+    Trigger: typeof Trigger;
+    Content: typeof Content;
+    Item: typeof Item;
+    Separator: typeof Separator;
+};
+
+interface ToasterProps {
+    labels?: ToasterLabels;
+}
+/** Stepbro's toast deck. Mount once near the root; show toasts with `toast()`. */
+declare function Toaster({ labels }: ToasterProps): react_jsx_runtime.JSX.Element;
+
+interface ChatBackgroundProps {
+    /** 0…1 (the microphone's, see audioEnergy); onboarding's busy state goes to 1.6. */
+    energy?: number;
+    scale?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+/** Stepbro's chat background. Put it first inside a positioned container. */
+declare function ChatBackground({ energy, scale, className, style }: ChatBackgroundProps): react_jsx_runtime.JSX.Element;
+
+interface ChatContextValue {
+    instance: MutableRefObject<ChatInstance | null>;
+    labels: ChatLabels;
+}
+declare const ChatContext: react.Context<ChatContextValue | null>;
+interface ChatRootProps extends HTMLAttributes<HTMLDivElement> {
+    onSend?: (text: string) => void;
+    animateExisting?: boolean;
+    labels?: ChatLabels;
+    children?: ReactNode;
+}
+declare function Root$1({ onSend, animateExisting, labels, className, children, ...props }: ChatRootProps): react_jsx_runtime.JSX.Element;
+interface ChatMessagesProps {
+    /** Waiting for an answer: "Pensando…" shows after 500 ms and morphs into the next assistant message. */
+    pending?: boolean;
+    children?: ReactNode;
+}
+interface MessagesState {
+    showPending: boolean;
+}
+type Snapshot = ReturnType<typeof capturePending>;
+/**
+ * The message list. A class component: only getSnapshotBeforeUpdate can measure
+ * the placeholder before React replaces it with the answer.
+ */
+declare class Messages extends Component<ChatMessagesProps, MessagesState> {
+    static contextType: react.Context<ChatContextValue | null>;
+    context: ContextType<typeof ChatContext>;
+    state: MessagesState;
+    private list;
+    private timer;
+    componentDidMount(): void;
+    componentDidUpdate(previous: ChatMessagesProps, _state: MessagesState, snapshot: Snapshot): void;
+    getSnapshotBeforeUpdate(previous: ChatMessagesProps): Snapshot;
+    componentWillUnmount(): void;
+    private wait;
+    render(): react_jsx_runtime.JSX.Element;
+}
+interface ChatMessageProps extends HTMLAttributes<HTMLDivElement> {
+    role?: ChatRole;
+    children?: ReactNode;
+}
+declare function Message({ role, children, ...props }: ChatMessageProps): react_jsx_runtime.JSX.Element;
+interface ChatComposerProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Extra buttons before send (a microphone…). */
+    actions?: ReactNode;
+    sendLabel?: string;
+}
+declare function Composer({ actions, sendLabel, placeholder, ...props }: ChatComposerProps): react_jsx_runtime.JSX.Element;
+declare function Confirm({ children, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+/**
+ * Stepbro's chat: <Chat.Root onSend><ChatBackground /><Chat.Messages pending>{messages.map(m =>
+ * <Chat.Message role>)}</Chat.Messages><Chat.Composer /></Chat.Root>.
+ */
+declare const Chat: {
+    Root: typeof Root$1;
+    Messages: typeof Messages;
+    Message: typeof Message;
+    Composer: typeof Composer;
+    Confirm: typeof Confirm;
+};
+/** The chat engine of the surrounding <Chat.Root> (setRecording, scrollToLatest…). */
+declare function useChat(): MutableRefObject<ChatInstance | null>;
+
+interface NavItem {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Render a link instead of a button. */
+    href?: string;
+    /** Hidden in the phone bar (Stepbro's hide-on-mobile). */
+    hideOnMobile?: boolean;
+}
+interface NavProps extends Omit<HTMLAttributes<HTMLElement>, 'onSelect'> {
+    items: NavItem[];
+    /** Value of the current page. */
+    active?: string;
+    onSelect?: (value: string, event: MouseEvent<HTMLElement>) => void;
+    navStyle?: NavStyle;
+    accent?: boolean;
+    /** Reveal the surrounding .mk-shell from the first button on mount. */
+    reveal?: boolean;
+    /** The top button (workspace, account…): give it className "mk-nav__button mk-nav__button--first". */
+    first?: ReactNode;
+    /** Buttons at the end (className "mk-nav__button mk-nav__button--action"). */
+    actions?: ReactNode;
+}
+/** Stepbro's navigation. Put it inside a <div className="mk-shell"> next to <main className="mk-shell__view">. */
+declare function Nav({ items, active, onSelect, navStyle, accent, reveal, first, actions, className, ...props }: NavProps): react_jsx_runtime.JSX.Element;
+
+interface StepsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Current step (0-based). Changing it flows to that step. */
+    index?: number;
+    onChange?: (index: number, previous: number) => void;
+    /** A step is working: the chat background inside speeds up (Stepbro's onBusy). */
+    busy?: boolean;
+    duration?: number;
+    children?: ReactNode;
+}
+declare function Root({ index, onChange, busy, duration, className, children, ...props }: StepsProps): react_jsx_runtime.JSX.Element;
+declare function Step({ children, ...props }: HTMLAttributes<HTMLElement>): react_jsx_runtime.JSX.Element;
+/** The step number; the engine rolls it (React only writes the first value). */
+declare function Counter(props: HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+/**
+ * Stepbro's onboarding: <Steps index={i} busy={working}><ChatBackground /><Steps.Counter />
+ * <Steps.Step><h2 data-mk-flow-item>…</h2></Steps.Step>…</Steps>. Steps must be direct children.
+ */
+declare const Steps: typeof Root & {
+    Step: typeof Step;
+    Counter: typeof Counter;
+};
+
+interface CursorProps {
+    /** 'chip' (Dousan, default) or 'dot' (Siena). */
+    variant?: CursorVariant;
+    /** dot: the word when nothing under the pointer gives one. */
+    text?: string;
+    arrows?: CursorOptions['arrows'];
+    /** CSS selector of the zone (dot: default the parent). */
+    zone?: string;
+    className?: string;
+}
+/** Put <Cursor /> once in the layout (chip), or inside the zone (dot). */
+declare function Cursor({ variant, text, arrows, zone, className }: CursorProps): react_jsx_runtime.JSX.Element;
+
+interface FrostProps {
+    /** Which edge the blur grows toward (default bottom). */
+    position?: 'bottom' | 'top';
+    /** Pin it to the window instead of the positioned parent. */
+    fixed?: boolean;
+    height?: number | string;
+    /** Multiplies the five blurs (default 1). */
+    strength?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+/** Dousan's progressive frost: five blur layers. Put it inside a positioned container (or use `fixed`). */
+declare function Frost({ position, fixed, height, strength, className, style }: FrostProps): react_jsx_runtime.JSX.Element;
+
+interface IslandPanel {
+    name: string;
+    /** Accessible name of its button. */
+    label: string;
+    /** Button content; the menu's nine dots by default. */
+    icon?: ReactNode;
+    /** Light button (iyo's cart). */
+    light?: boolean;
+    content: ReactNode;
+}
+interface IslandProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'>, Omit<IslandOptions, 'onChange'> {
+    brand?: ReactNode;
+    /** The call to action that fades out while a panel is open. */
+    cta?: {
+        href: string;
+        label: ReactNode;
+    };
+    panels: IslandPanel[];
+    /** Keep it (and its backdrop) inside a positioned parent instead of fixed over the page. */
+    contained?: boolean;
+    onChange?: (active: string | null) => void;
+    /** Receives the live instance (open, close, toggle, ready). */
+    instanceRef?: {
+        current: IslandInstance | null;
+    };
+}
+/** The nine static dots of iyo's menu button. */
+declare function IslandDots(): react_jsx_runtime.JSX.Element;
+/** iyo.ai's floating navbar. */
+declare function Island({ brand, cta, panels, contained, entrance, closeOnScroll, closeOnNavigate, focusOnOpen, onChange, instanceRef, className, ...props }: IslandProps): react_jsx_runtime.JSX.Element;
+
+export { AnimatedNumber, type AnimatedNumberProps, Chat, ChatBackground, type ChatBackgroundProps, type ChatComposerProps, type ChatMessageProps, type ChatMessagesProps, type ChatRootProps, Cursor, type CursorProps, Dialog, type DialogContentProps, FlipGroup, type FlipGroupProps, Frost, type FrostProps, Island, IslandDots, type IslandPanel, type IslandProps, Menu, type MenuRootProps, MkIcon, Nav, type NavItem, type NavProps, NavStyle, SlotText, type SlotTextProps, Steps, type StepsProps, type SurfaceRootProps, type ThemeContextValue, ThemePicker, type ThemePickerProps, ThemeProvider, type ThemeProviderProps, Toaster, type ToasterProps, type UseStretchFooterOptions, useCardDock, useCascade, useChat, useContrast, useCounter, useCurvedCarousel, useDepthGrid, useDetails, useDialog, useDockPill, useDragRuler, useFillText, useFitText, useFlow, useFrameZoom, useInfiniteReel, useIsomorphicLayoutEffect, useLatest, useLetters, useLiquidBlend, useMarquee, useMaskText, useMatcap, useParallax, useParticleHero, usePile, usePop, useRadialMenu, useRecipe, useReflow, useRepelBento, useReveal, useRotator, useShaderBlur, useShaderGrain, useSlotText, useSnapStrip, useSortable, useSpringCards, useStretchFooter, useTabs, useTextRoll, useTheme, useTicketMenu, useWords };