@mkbabb/glass-ui 4.1.0 → 5.0.0

package/dist/components/tabs/composables/useTabRovingFocus.d.ts

@@ -0,0 +1,51 @@
+import type { ComputedRef, Ref } from "vue";
+/**
+ * The minimal roving option shape — the machine reads ONLY `value` + `disabled`
+ * (BI.W-DOCK-CONTROLS decoupled it from `SegmentedTabOption` so the shared
+ * headless `useSelectionGroup` can compose it VERBATIM over its generic option
+ * type). Any richer option (the tabs' `SegmentedTabOption`) is structurally
+ * assignable.
+ */
+export interface RovingSelectionOption {
+    value: string;
+    disabled?: boolean;
+}
+/**
+ * Package-private composable for `SegmentedTabs.vue` — BG.W-COLOCATE (the WS4
+ * roving-focus/responsive carve; ratchet-drain #13). The WAI-ARIA tablist/toolbar
+ * roving-tabindex keyboard machine lives here, carved out of the SFC to hold the
+ * no-god-module bound. BI.W-DOCK-CONTROLS composes it VERBATIM inside the shared
+ * headless `useSelectionGroup` (the dock IS SegmentedTabs/ToggleGroup wearing
+ * chrome — ONE roving machine, never re-forked). The SFC IMPORTS it and binds
+ * `:tabindex="rovingTabindex(idx)"` + `@keydown="onStripKeydown"` in its template.
+ *
+ * EXACTLY ONE tab in the focus order (the active tab `tabindex="0"`, the rest `-1`);
+ * the arrow keys move focus + activate (selection-follows-focus). The arrow AXIS is
+ * derived off `isVertical` (ArrowRight/Left horizontal, ArrowDown/Up vertical),
+ * Home/End jump, wrapping at the ends, skipping disabled. This is the keyboard contract
+ * EVERY strip owes — NOT gated on `:draggable` (a draggable tab that is keyboard-broken
+ * is the worse failure). The keyboard activation IS a selection → the SFC's `select(...)`
+ * path (with its `squishOnTravel`), passed in as a callback (byte-behaviour identical to
+ * the prior inline block).
+ */
+export interface UseTabRovingFocusParams {
+    /** The options the strip renders (index-aligned to `buttonRefs`). */
+    stripOptions: ComputedRef<readonly RovingSelectionOption[]>;
+    /** The value the strip renders (the ONE tabstop anchor). */
+    stripValue: ComputedRef<string | undefined>;
+    /** True for the vertical (block-axis) orientation — flips the arrow axis. */
+    isVertical: ComputedRef<boolean>;
+    /** Per-option button refs, index-aligned to `stripOptions`. */
+    buttonRefs: Ref<HTMLElement[]>;
+    /** The SFC's selection handler (focus-follows activation → model write + squish). */
+    select: (value: string, idx: number) => void;
+}
+export interface UseTabRovingFocusReturn {
+    /** The active index in the rendered strip — the ONE tabstop. */
+    activeIndex: ComputedRef<number>;
+    /** The roving tabindex for option `idx`: `0` for the active tab, `-1` otherwise. */
+    rovingTabindex: (idx: number) => number;
+    /** The strip-root keydown handler (axis-derived arrows + Home/End). */
+    onStripKeydown: (e: KeyboardEvent) => void;
+}
+export declare function useTabRovingFocus(params: UseTabRovingFocusParams): UseTabRovingFocusReturn;

package/dist/components/tabs/constants.d.ts

@@ -0,0 +1 @@
+export { DEFAULT_INDICATOR_MAX_STRETCH, DEFAULT_INDICATOR_BLOB_MAX, INDICATOR_RELEASE_AT_ARRIVAL, } from "../../composables/motion/useSelectionIndicator";

package/dist/components/timeline/ContinuousMarkers.vue.d.ts

@@ -0,0 +1,49 @@
+import type { TimelineSegment } from "./types";
+/**
+ * <ContinuousMarkers> — the interactive marker overlay of the
+ * continuous-variant timeline. DECK-PRIVATE child of <ContinuousTimeline>
+ * (not a public export). Renders the sibling `<ul role="list">` overlay
+ * carrying one focusable button per segment boundary, each (by default)
+ * wrapped in <HoverPopover>. Lives OUTSIDE the rail's `overflow: hidden`
+ * clip and is a SIBLING of the progressbar rail (Option C structural
+ * split, AB.W2.T4).
+ *
+ * The split is a pure transposition out of the prior monolithic
+ * ContinuousTimeline.vue: same DOM, same class names, same data
+ * attributes, same scoped CSS rules. The orchestrator owns the hovered-key
+ * state + the `#detail` resolution; this child emits the raw
+ * hover/hoverEnd/click signals (popover-open-change drives hover/hoverEnd
+ * on the default path; raw mouseenter/leave on the bare-fallback path) and
+ * forwards the consumer's `#popoverContent` slot through the
+ * `popoverContent` slot.
+ */
+type __VLS_Props = {
+    segments: TimelineSegment[];
+    markersAriaLabel: string;
+    currentSegmentKey?: string;
+    disablePopover?: boolean;
+    boundaryX: (i: number) => number;
+};
+declare var __VLS_21: {
+    segment: TimelineSegment;
+};
+type __VLS_Slots = {} & {
+    popoverContent?: (props: typeof __VLS_21) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (seg: TimelineSegment) => any;
+    hover: (seg: TimelineSegment) => any;
+    hoverEnd: (seg: TimelineSegment) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((seg: TimelineSegment) => any) | undefined;
+    onHover?: ((seg: TimelineSegment) => any) | undefined;
+    onHoverEnd?: ((seg: TimelineSegment) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/timeline/GlassTimeline.vue.d.ts

@@ -0,0 +1,114 @@
+import type { TimelineSegment } from "./types";
+/**
+ * <GlassTimeline> — dispatcher SFC for three structurally-distinct
+ * timeline variants. Public surface UNCHANGED from the pre-O.W3 god-module.
+ *
+ * - `variant="scrubber"` (default): single-track normalized 0..1 scrubber
+ *   with full keyboard a11y (role=slider + arrow-key step + shift-step).
+ *   Delegates to `<ScrubberTimeline>`.
+ *
+ * - `variant="segmented"` (Z.W2.T1 / A2 §B5): adjacent gradient bands,
+ *   one per phase, with boundary dots that emit `hover` + `click` events
+ *   carrying the segment key + payload. Delegates to `<SegmentedTimeline>`.
+ *
+ * - `variant="continuous"` (AA.W1 / A4 §S-17): ONE rounded-pill rail
+ *   substrate with N absolute-positioned region children. Delegates to
+ *   `<ContinuousTimeline>`. The continuous variant owns the popover
+ *   portal CSS contract (non-scoped <style> block; see ContinuousTimeline).
+ *
+ * Per-segment gradient: either `{from, to}` (expanded as 90deg L→R linear
+ * gradient) or a raw CSS gradient string consumed verbatim. Falls back
+ * to `--timeline-segment-default-gradient` when omitted.
+ *
+ * O.W3 Lane A — this dispatcher replaces the prior 1049-line monolith.
+ * The three variant SFCs + `geometry.ts` shared math live alongside in
+ * the same package. Consumer imports through
+ * `@mkbabb/glass-ui/timeline` are unchanged.
+ */
+type __VLS_Props = {
+    /** Variant — default `scrubber`. */
+    variant?: "scrubber" | "segmented" | "continuous";
+    /** 0..1 scrubber position. Required for scrubber variant. */
+    modelValue?: number;
+    /** Tooltip caret text (scrubber variant only). */
+    label?: string;
+    /** Phase descriptors (segmented + continuous variants). */
+    segments?: TimelineSegment[];
+    /**
+     * Optional aria-label for the continuous variant's rail
+     * (role=progressbar). Falls back to a comma-joined list of segment
+     * labels when omitted.
+     */
+    ariaLabel?: string;
+    /**
+     * AB.W2.T3 (A2 §B2.b) — current segment key (continuous variant).
+     * Stamps `data-current="true"` on the matching marker so consumers
+     * (panel / W3 raised-rivet styling) can distinguish the active
+     * phase from the transient hovered phase.
+     */
+    currentSegmentKey?: string;
+    /**
+     * AB.W2.T2 (A4 §B2.c) — disable the default per-marker
+     * HoverPopover (continuous variant). The dot still emits
+     * `hover` / `click` events.
+     */
+    disablePopover?: boolean;
+};
+declare var __VLS_13: {
+    segment: TimelineSegment;
+}, __VLS_16: {
+    segment: TimelineSegment | null;
+    source: "idle" | "current" | "hovered";
+    currentKey: string | null;
+    hoveredKey: string | null;
+};
+type __VLS_Slots = {} & {
+    popoverContent?: (props: typeof __VLS_13) => any;
+} & {
+    detail?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any;
+    hover: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any;
+    "update:modelValue": (v: number) => any;
+    hoverEnd: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any;
+    scrubStart: () => any;
+    scrubEnd: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+    onHover?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    onHoverEnd?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+    onScrubStart?: (() => any) | undefined;
+    onScrubEnd?: (() => any) | undefined;
+}>, {
+    variant: "scrubber" | "segmented" | "continuous";
+    modelValue: number;
+    disablePopover: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/timeline/ScrubberTimeline.vue.d.ts

@@ -0,0 +1,45 @@
+/**
+ * <ScrubberTimeline> — single-track normalized 0..1 scrubber.
+ *
+ * Internal variant SFC dispatched from <GlassTimeline variant="scrubber">.
+ * Owns the pre-Z.W2 single-track contract: pointer-capture drag, keyboard
+ * a11y (role=slider + arrow-key step + shift-step), `label` tooltip caret.
+ *
+ * AA.A4 §S-16 — the `aria-valuenow` binding coerces `Number(modelValue ?? 0)`
+ * so a numeric attribute always renders (axe `aria-required-attr` regression).
+ *
+ * BD.W-TIMELINE-RAIL-UNIFY (LEG 2) — the head is RE-INVENTED as a warm-glass
+ * liquid lozenge. The four cartoon beats COMPOSE shipped engines only (no new
+ * motion engine): travel rides a `useSpring`/SpringProgress position written
+ * to `transform: translateX()` (NEVER `style.left` — Safari composites
+ * transform, not left); `useLiquidFlex` `"tanh"` velocity-squish multiplies
+ * into the SAME matrix (vol-preserving, cap ≤1.12); `useSpringPress` grab
+ * anticipation; the velocity term is the head spring's own derivative (the
+ * self-extinguishing per-frame velocity SpringProgress already computes — the
+ * GOLDEN §0 "drive off the spring derivative" path, no free-running rAF); the
+ * fill LAGS the head on a slower spring clock; release settles ζ<1 on the
+ * cartoon-punch clock; a one-shot accent-flood ripples on landing. Always
+ * visible (the
+ * `opacity:0`-until-hover is RETIRED — the affordance must be present during
+ * keyboard/touch scrub). The bead seats φ-INSIDE the channel; the 44px touch
+ * target is an invisible `::before` halo, decoupled from the visible bead.
+ */
+type __VLS_Props = {
+    /** 0..1 scrubber position. */
+    modelValue?: number;
+    /** Tooltip caret text. */
+    label?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (v: number) => any;
+    scrubStart: () => any;
+    scrubEnd: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    onScrubStart?: (() => any) | undefined;
+    onScrubEnd?: (() => any) | undefined;
+}>, {
+    modelValue: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/timeline/geometry.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Timeline shared geometry — pure math + payload helpers used by ≥ 2 of
+ * the variant SFCs (ScrubberTimeline / SegmentedTimeline / ContinuousTimeline).
+ *
+ * Split out of the prior monolithic `GlassTimeline.vue` per O.W3 Lane A —
+ * the geometry was identical across the segmented + continuous variants,
+ * and the popover-payload helper is consumed only by the continuous variant
+ * today but its shape (the AA-canonical `{ label, value, description, state }`
+ * envelope) is documented as the shared per-segment hover-payload contract.
+ *
+ * All exports are pure functions or type aliases — no Vue runtime imports,
+ * no side effects. The factory `createContinuousGeometry(segmentsRef)`
+ * returns the `totalWeight` + region/boundary helpers bound to a live
+ * `Ref<TimelineSegment[]>`, so the continuous SFC can drop them straight
+ * into its `<script setup>`.
+ */
+import { type ComputedRef, type Ref } from "vue";
+import type { TimelineSegment } from "./types";
+/**
+ * Fill percentage per state. Explicit `progress` wins; otherwise the
+ * canonical mapping (pending=0, active=0.5, completed=1). Clamped to
+ * [0, 1] so consumers can't paint past the segment box.
+ */
+export declare function fillFor(seg: TimelineSegment): number;
+/** Resolve a segment's positive weight; defaults to 1. */
+export declare function segmentWeight(seg: TimelineSegment): number;
+/**
+ * Bind continuous-variant geometry helpers to a live `Ref<TimelineSegment[]>`.
+ * Returns the `totalWeight` ComputedRef + per-index region geometry
+ * (regionLeft, regionWidth, boundaryX) + the rail's aggregate aria-valuenow
+ * computation. The continuous SFC pulls these into its `<script setup>`.
+ */
+export declare function createContinuousGeometry(segments: Ref<TimelineSegment[]>): {
+    totalWeight: ComputedRef<number>;
+    regionLeft: (i: number) => number;
+    regionWidth: (i: number) => number;
+    boundaryX: (i: number) => number;
+    continuousAriaValueNow: ComputedRef<number>;
+};
+/**
+ * Build the ONE rail-spanning stitched gradient for the continuous
+ * variant. Each phase's colour is anchored as a stop at the CENTRE of
+ * its weight-share so the pure hue sits mid-phase and the hues cross-
+ * fade smoothly through every boundary. The first and last stops are
+ * pinned to 0% / 100% so the bar's ends saturate fully (no washed
+ * leading/trailing edge). Returns a `linear-gradient(90deg, …)` string
+ * sized to the FULL rail width.
+ */
+export declare function stitchedRailGradient(segments: TimelineSegment[]): string;
+/**
+ * Per-region windowing parameters for the stitched rail gradient. The
+ * region paints the FULL-rail gradient (`stitchedRailGradient`) but only
+ * its own slice is visible inside the region box. To window correctly
+ * the region's `background-size-x` is scaled to `1 / regionWidth` of the
+ * region box (so the full gradient spans `regionWidth` of the rail) and
+ * the `background-position-x` is offset so the region's left edge aligns
+ * with the rail-fraction `regionLeft`.
+ *
+ * `sizeX`     — CSS `background-size` x value, e.g. `"333.333%"`.
+ * `positionX` — CSS `background-position` x value, e.g. `"50%"`.
+ *
+ * background-position interpolates the image's `(size - box)` overflow,
+ * so the position fraction is `regionLeft / (1 - regionWidth)` (guarded
+ * for the degenerate single-region `regionWidth == 1` case).
+ */
+export declare function stitchedRegionWindow(regionLeft: number, regionWidth: number): {
+    sizeX: string;
+    positionX: string;
+};
+/**
+ * Continuous-variant active-region fill width (0..1, applied as a clip
+ * mask on the region's right edge for partial-fill animation). For
+ * `completed` returns 1; for `pending` returns 0; for `active` returns
+ * `fillFor(seg)` (which honours explicit `progress` overrides).
+ */
+export declare function continuousFillWidth(seg: TimelineSegment): number;
+/**
+ * AB.W2.T2 — default popover content payload shape.
+ *
+ * Reads `value` shape if the consumer supplied the AA-canonical
+ * `{ label, value, description, state }` payload (the speedtest
+ * PhaseDetail), otherwise falls back to the segment's own label/state.
+ * The slot scope exposes the full segment so consumers can override
+ * entirely.
+ */
+export interface DefaultPopoverPayload {
+    label?: string;
+    value?: unknown;
+    description?: string;
+    state?: string;
+}
+export declare function popoverPayloadFor(seg: TimelineSegment): DefaultPopoverPayload;

package/dist/components/toast/Toast.vue.d.ts

@@ -0,0 +1,107 @@
+import { type HTMLAttributes } from 'vue';
+import { type ToastRootProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
+import type { Tone } from '../_shared/axes';
+interface ToastProps extends ToastRootProps {
+    class?: HTMLAttributes['class'];
+    tone?: Tone;
+    surface?: Surface;
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    pause: () => any;
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    resume: () => any;
+    swipeStart: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeMove: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeCancel: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeEnd: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+}, string, import("vue").PublicProps, Readonly<ToastProps> & Readonly<{
+    onPause?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onResume?: (() => any) | undefined;
+    onSwipeStart?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeMove?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeCancel?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeEnd?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+}>, {
+    tone: Tone;
+    surface: Surface;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,9 @@
+export { default as Toast } from './Toast.vue';
+export { default as ToastAction } from './ToastAction.vue';
+export { default as ToastClose } from './ToastClose.vue';
+export { default as ToastDescription } from './ToastDescription.vue';
+export { default as ToastTitle } from './ToastTitle.vue';
+export { default as Toaster } from './Toaster.vue';
+export { toast, useToast } from './use-toast';
+export type { Toast as ToastType } from './use-toast';
+export type { ToasterPosition } from './Toaster.vue';

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

@@ -0,0 +1,182 @@
+import type { Component, VNode } from 'vue';
+import type { Surface } from '../_shared/useSurfaceAxis';
+import type { Tone } from '../_shared/axes';
+export interface Toast {
+    id: string;
+    title?: string;
+    description?: string;
+    action?: Component | VNode;
+    tone?: Tone;
+    /**
+     * BB.W-SURFACE-AXIS-COMPLETE — the shared {glass·veil·opaque} surface-decoration
+     * axis on a queued toast (default `glass`). Forwarded through `Toaster.vue`'s
+     * per-toast `v-bind` exactly like `variant`; orthogonal to the tone arm.
+     */
+    surface?: Surface;
+    /**
+     * Auto-dismiss delay in ms, forwarded to reka-ui's `ToastRoot`. Omit to
+     * inherit the `ToastProvider` default; `Number.POSITIVE_INFINITY` keeps the
+     * toast open until dismissed.
+     */
+    duration?: number;
+}
+type ToasterToast = Toast & {
+    id: string;
+    title?: string;
+    description?: string;
+    action?: Component | VNode;
+    open?: boolean;
+    'onUpdate:open'?: (open: boolean) => void;
+};
+type ToastOptions = Omit<ToasterToast, 'id'>;
+declare function toast(props: ToastOptions): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toasts: import("vue").ComputedRef<{
+        id: string;
+        title?: string | undefined;
+        description?: string | undefined;
+        action?: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").FunctionalComponent<any, {}, any, {}> | {
+            new (...args: any[]): any;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } | {
+            [x: string]: any;
+            setup?: ((this: void, props: import("@vue/shared").LooseRequired<any>, ctx: {
+                attrs: import("vue").Attrs;
+                slots: Readonly<{
+                    [name: string]: import("vue").Slot<any> | undefined;
+                }>;
+                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
+                expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+            }) => any) | undefined;
+            name?: string | undefined;
+            template?: string | object | undefined;
+            render?: Function | undefined;
+            components?: Record<string, Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>> | undefined;
+            directives?: Record<string, import("vue").Directive<any, any, string, any>> | undefined;
+            inheritAttrs?: boolean | undefined;
+            emits?: any;
+            slots?: {} | undefined;
+            expose?: string[] | undefined;
+            serverPrefetch?: (() => void | Promise<any>) | undefined;
+            compilerOptions?: {
+                isCustomElement?: ((tag: string) => boolean) | undefined;
+                whitespace?: "preserve" | "condense" | undefined;
+                comments?: boolean | undefined;
+                delimiters?: [string, string] | undefined;
+            } | undefined;
+            call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
+            __isFragment?: never | undefined;
+            __isTeleport?: never | undefined;
+            __isSuspense?: never | undefined;
+            __defaults?: {} | undefined;
+            compatConfig?: {
+                GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
+                GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
+                GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_SET?: boolean | "suppress-warning" | undefined;
+                GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
+                CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
+                CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
+                CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
+                CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
+                CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
+                CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
+                CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SET?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
+                INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
+                WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
+                PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
+                V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
+                CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
+                ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
+                ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
+                TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
+                TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
+                COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
+                COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
+                COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
+                RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
+                FILTERS?: boolean | "suppress-warning" | undefined;
+                PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
+                MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3) | undefined;
+            } | undefined;
+            data?: ((this: any, vm: any) => any) | undefined;
+            computed?: import("vue").ComputedOptions | undefined;
+            methods?: import("vue").MethodOptions | undefined;
+            watch?: {
+                [x: string]: (string | import("vue").WatchCallback | ({
+                    handler: import("vue").WatchCallback | string;
+                } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback | ({
+                    handler: import("vue").WatchCallback | string;
+                } & import("vue").WatchOptions<boolean>))[];
+            } | undefined;
+            provide?: import("vue").ComponentProvideOptions | undefined;
+            inject?: {} | string[] | undefined;
+            filters?: Record<string, Function> | undefined;
+            mixins?: any[] | undefined;
+            extends?: any;
+            beforeCreate?: (() => any) | undefined;
+            created?: (() => any) | undefined;
+            beforeMount?: (() => any) | undefined;
+            mounted?: (() => any) | undefined;
+            beforeUpdate?: (() => any) | undefined;
+            updated?: (() => any) | undefined;
+            activated?: (() => any) | undefined;
+            deactivated?: (() => any) | undefined;
+            beforeDestroy?: (() => any) | undefined;
+            beforeUnmount?: (() => any) | undefined;
+            destroyed?: (() => any) | undefined;
+            unmounted?: (() => any) | undefined;
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | undefined;
+            delimiters?: [string, string] | undefined;
+            __differentiator?: string | number | symbol | undefined;
+            __isBuiltIn?: boolean | undefined;
+            __file?: string | undefined;
+            __name?: string | undefined;
+        } | undefined;
+        tone?: Tone
+        /**
+         * BB.W-SURFACE-AXIS-COMPLETE — the shared {glass·veil·opaque} surface-decoration
+         * axis on a queued toast (default `glass`). Forwarded through `Toaster.vue`'s
+         * per-toast `v-bind` exactly like `variant`; orthogonal to the tone arm.
+         */
+         | undefined;
+        surface?: Surface
+        /**
+         * Auto-dismiss delay in ms, forwarded to reka-ui's `ToastRoot`. Omit to
+         * inherit the `ToastProvider` default; `Number.POSITIVE_INFINITY` keeps the
+         * toast open until dismissed.
+         */
+         | undefined;
+        duration?: number | undefined;
+        open?: boolean | undefined;
+        'onUpdate:open'?: ((open: boolean) => void) | undefined;
+    }[]>;
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+};
+export { toast, useToast };