@skdx/react 0.26.0

package/dist/tour/TourPortal.d.ts

@@ -0,0 +1,24 @@
+import type { TourPortalProps } from './types.js';
+/**
+ * Teleports the tour's layer — backdrop, spotlight and content — to
+ * `document.body` (or a custom `container`), so it escapes any clipping or
+ * `overflow` ancestor of the element the tour happens to be pointing at.
+ * Stays mounted through `TourContent`'s CSS exit animation and unmounts once
+ * it ends, or immediately when none is declared, unless `forceMount` is set.
+ *
+ * @example
+ * ```tsx
+ * <Tour steps={steps}>
+ *   <TourTrigger>Take the tour</TourTrigger>
+ *   <TourPortal>
+ *     <TourBackdrop />
+ *     <TourSpotlight />
+ *     <TourContent>…</TourContent>
+ *   </TourPortal>
+ * </Tour>
+ * ```
+ */
+export declare const TourPortal: {
+    ({ forceMount, children, ...props }: TourPortalProps): import("react").JSX.Element | null;
+    displayName: string;
+};

package/dist/tour/TourPrevTrigger.d.cts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { TourPrevTriggerProps } from './types.cjs';
+/**
+ * Button that steps the tour back. Disabled on the first step — there is
+ * nowhere to go, and a button that silently does nothing is worse than one
+ * that says so — and exposes `data-disabled` for styling. Pass `disabled`
+ * yourself to disable it on other steps too.
+ *
+ * @example
+ * ```tsx
+ * <TourPrevTrigger>Back</TourPrevTrigger>
+ * ```
+ */
+export declare const TourPrevTrigger: React.ForwardRefExoticComponent<Omit<TourPrevTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tour/TourPrevTrigger.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { TourPrevTriggerProps } from './types.js';
+/**
+ * Button that steps the tour back. Disabled on the first step — there is
+ * nowhere to go, and a button that silently does nothing is worse than one
+ * that says so — and exposes `data-disabled` for styling. Pass `disabled`
+ * yourself to disable it on other steps too.
+ *
+ * @example
+ * ```tsx
+ * <TourPrevTrigger>Back</TourPrevTrigger>
+ * ```
+ */
+export declare const TourPrevTrigger: React.ForwardRefExoticComponent<Omit<TourPrevTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tour/TourProgressText.d.cts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { TourProgressTextProps } from './types.cjs';
+/**
+ * The visible "Step 2 of 5" line, as a `<p>` also carrying `data-step` and
+ * `data-total`. Pass `format` to translate it, or `children` to render the
+ * position yourself.
+ *
+ * Not a live region: the same information is already spoken on every step
+ * change through the tour's own announcement, and a second live region would
+ * make a screen reader say it twice.
+ *
+ * @example
+ * ```tsx
+ * <TourProgressText format={(index, total) => `${index + 1} / ${total}`} />
+ * ```
+ */
+export declare const TourProgressText: React.ForwardRefExoticComponent<Omit<TourProgressTextProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;

package/dist/tour/TourProgressText.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { TourProgressTextProps } from './types.js';
+/**
+ * The visible "Step 2 of 5" line, as a `<p>` also carrying `data-step` and
+ * `data-total`. Pass `format` to translate it, or `children` to render the
+ * position yourself.
+ *
+ * Not a live region: the same information is already spoken on every step
+ * change through the tour's own announcement, and a second live region would
+ * make a screen reader say it twice.
+ *
+ * @example
+ * ```tsx
+ * <TourProgressText format={(index, total) => `${index + 1} / ${total}`} />
+ * ```
+ */
+export declare const TourProgressText: React.ForwardRefExoticComponent<Omit<TourProgressTextProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;

package/dist/tour/TourSkipTrigger.d.cts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { TourSkipTriggerProps } from './types.cjs';
+/**
+ * Button that ends the tour early: closes it and fires `onSkip`, never
+ * `onComplete`. The explicit "Skip tour" affordance — every tour needs one on
+ * every step, since a user who already knows the product must be able to get
+ * out without clicking through.
+ *
+ * @example
+ * ```tsx
+ * <TourSkipTrigger>Skip tour</TourSkipTrigger>
+ * ```
+ */
+export declare const TourSkipTrigger: React.ForwardRefExoticComponent<Omit<TourSkipTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tour/TourSkipTrigger.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { TourSkipTriggerProps } from './types.js';
+/**
+ * Button that ends the tour early: closes it and fires `onSkip`, never
+ * `onComplete`. The explicit "Skip tour" affordance — every tour needs one on
+ * every step, since a user who already knows the product must be able to get
+ * out without clicking through.
+ *
+ * @example
+ * ```tsx
+ * <TourSkipTrigger>Skip tour</TourSkipTrigger>
+ * ```
+ */
+export declare const TourSkipTrigger: React.ForwardRefExoticComponent<Omit<TourSkipTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tour/TourSpotlight.d.cts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { TourSpotlightProps } from './types.cjs';
+/**
+ * The highlight box sitting over the active step's target, carrying the same
+ * `--skdx-tour-x` / `-y` / `-width` / `-height` geometry as `TourBackdrop` so a
+ * ring, glow or cut-out can be positioned from CSS alone.
+ *
+ * Renders nothing when the active step has no resolved target — a centred step
+ * spotlights nothing, and an empty box parked at the top-left corner would be
+ * worse than no box. Decorative and `aria-hidden`.
+ *
+ * @example
+ * ```css
+ * .tour-spotlight {
+ *   position: fixed;
+ *   left: var(--skdx-tour-x);
+ *   top: var(--skdx-tour-y);
+ *   width: var(--skdx-tour-width);
+ *   height: var(--skdx-tour-height);
+ *   box-shadow: 0 0 0 9999px rgb(0 0 0 / 0.5);
+ * }
+ * ```
+ */
+export declare const TourSpotlight: React.ForwardRefExoticComponent<Omit<TourSpotlightProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/tour/TourSpotlight.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { TourSpotlightProps } from './types.js';
+/**
+ * The highlight box sitting over the active step's target, carrying the same
+ * `--skdx-tour-x` / `-y` / `-width` / `-height` geometry as `TourBackdrop` so a
+ * ring, glow or cut-out can be positioned from CSS alone.
+ *
+ * Renders nothing when the active step has no resolved target — a centred step
+ * spotlights nothing, and an empty box parked at the top-left corner would be
+ * worse than no box. Decorative and `aria-hidden`.
+ *
+ * @example
+ * ```css
+ * .tour-spotlight {
+ *   position: fixed;
+ *   left: var(--skdx-tour-x);
+ *   top: var(--skdx-tour-y);
+ *   width: var(--skdx-tour-width);
+ *   height: var(--skdx-tour-height);
+ *   box-shadow: 0 0 0 9999px rgb(0 0 0 / 0.5);
+ * }
+ * ```
+ */
+export declare const TourSpotlight: React.ForwardRefExoticComponent<Omit<TourSpotlightProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/tour/TourTitle.d.cts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { TourTitleProps } from './types.cjs';
+/**
+ * The active step's accessible name: renders an `<h2>` wired to `TourContent`
+ * via `aria-labelledby`. Every step should have one.
+ *
+ * This is the *visible* heading. The string announced on a step change comes
+ * from the step's own `title` in the `steps` array — set both, and keep them
+ * saying the same thing.
+ *
+ * @example
+ * ```tsx
+ * <TourContent>
+ *   <TourTitle>Your inbox</TourTitle>
+ * </TourContent>
+ * ```
+ */
+export declare const TourTitle: React.ForwardRefExoticComponent<Omit<TourTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;

package/dist/tour/TourTitle.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { TourTitleProps } from './types.js';
+/**
+ * The active step's accessible name: renders an `<h2>` wired to `TourContent`
+ * via `aria-labelledby`. Every step should have one.
+ *
+ * This is the *visible* heading. The string announced on a step change comes
+ * from the step's own `title` in the `steps` array — set both, and keep them
+ * saying the same thing.
+ *
+ * @example
+ * ```tsx
+ * <TourContent>
+ *   <TourTitle>Your inbox</TourTitle>
+ * </TourContent>
+ * ```
+ */
+export declare const TourTitle: React.ForwardRefExoticComponent<Omit<TourTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;

package/dist/tour/TourTrigger.d.cts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import type { TourTriggerProps } from './types.cjs';
+/**
+ * Button that starts the tour. Sets `aria-haspopup="dialog"`,
+ * `aria-expanded`, `aria-controls` pointing at `TourContent`, and `data-state`
+ * (`open`/`closed`).
+ *
+ * It is also where focus goes back to when the tour completes or is skipped —
+ * whatever was focused when the tour started is what the focus trap restores,
+ * and for a tour started from a button that is this button.
+ *
+ * @example
+ * ```tsx
+ * <Tour steps={steps}>
+ *   <TourTrigger>Take the tour</TourTrigger>
+ *   <TourPortal>…</TourPortal>
+ * </Tour>
+ * ```
+ */
+export declare const TourTrigger: React.ForwardRefExoticComponent<Omit<TourTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tour/TourTrigger.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import type { TourTriggerProps } from './types.js';
+/**
+ * Button that starts the tour. Sets `aria-haspopup="dialog"`,
+ * `aria-expanded`, `aria-controls` pointing at `TourContent`, and `data-state`
+ * (`open`/`closed`).
+ *
+ * It is also where focus goes back to when the tour completes or is skipped —
+ * whatever was focused when the tour started is what the focus trap restores,
+ * and for a tour started from a button that is this button.
+ *
+ * @example
+ * ```tsx
+ * <Tour steps={steps}>
+ *   <TourTrigger>Take the tour</TourTrigger>
+ *   <TourPortal>…</TourPortal>
+ * </Tour>
+ * ```
+ */
+export declare const TourTrigger: React.ForwardRefExoticComponent<Omit<TourTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tour/index.d.cts

@@ -0,0 +1,15 @@
+export { Tour } from './Tour.cjs';
+export { TourTrigger } from './TourTrigger.cjs';
+export { TourPortal } from './TourPortal.cjs';
+export { TourBackdrop } from './TourBackdrop.cjs';
+export { TourSpotlight } from './TourSpotlight.cjs';
+export { TourContent } from './TourContent.cjs';
+export { TourArrow } from './TourArrow.cjs';
+export { TourTitle } from './TourTitle.cjs';
+export { TourDescription } from './TourDescription.cjs';
+export { TourProgressText } from './TourProgressText.cjs';
+export { TourNextTrigger } from './TourNextTrigger.cjs';
+export { TourPrevTrigger } from './TourPrevTrigger.cjs';
+export { TourSkipTrigger } from './TourSkipTrigger.cjs';
+export { TourCloseTrigger } from './TourCloseTrigger.cjs';
+export type { TourStep, TourStepType, TourProps, TourTriggerProps, TourPortalProps, TourBackdropProps, TourSpotlightProps, TourContentProps, TourArrowProps, TourTitleProps, TourDescriptionProps, TourProgressTextProps, TourNextTriggerProps, TourPrevTriggerProps, TourSkipTriggerProps, TourCloseTriggerProps, } from './types.cjs';

package/dist/tour/index.d.ts

@@ -0,0 +1,15 @@
+export { Tour } from './Tour.js';
+export { TourTrigger } from './TourTrigger.js';
+export { TourPortal } from './TourPortal.js';
+export { TourBackdrop } from './TourBackdrop.js';
+export { TourSpotlight } from './TourSpotlight.js';
+export { TourContent } from './TourContent.js';
+export { TourArrow } from './TourArrow.js';
+export { TourTitle } from './TourTitle.js';
+export { TourDescription } from './TourDescription.js';
+export { TourProgressText } from './TourProgressText.js';
+export { TourNextTrigger } from './TourNextTrigger.js';
+export { TourPrevTrigger } from './TourPrevTrigger.js';
+export { TourSkipTrigger } from './TourSkipTrigger.js';
+export { TourCloseTrigger } from './TourCloseTrigger.js';
+export type { TourStep, TourStepType, TourProps, TourTriggerProps, TourPortalProps, TourBackdropProps, TourSpotlightProps, TourContentProps, TourArrowProps, TourTitleProps, TourDescriptionProps, TourProgressTextProps, TourNextTriggerProps, TourPrevTriggerProps, TourSkipTriggerProps, TourCloseTriggerProps, } from './types.js';

package/dist/tour/types.d.cts

@@ -0,0 +1,261 @@
+import type * as React from 'react';
+import type { Align, PopperContentProps, Side } from '../utils/popper.cjs';
+import type { PortalProps } from '../utils/portal.cjs';
+import type { PrimitivePropsWithRef } from '../utils/primitive.cjs';
+import type { FocusOutsideEvent, InteractOutsideEvent } from '../utils/useDismiss.cjs';
+/**
+ * How a step presents itself. `tooltip` and `floating` both anchor to the
+ * step's target; `dialog` renders centred even when a target is present, so a
+ * step can spotlight an element while explaining it from the middle of the
+ * screen. Published as `data-type` on `TourContent` either way.
+ */
+export type TourStepType = 'tooltip' | 'dialog' | 'floating';
+/** One step of a {@link Tour}. Steps are data, not markup — the whole list is passed to the root. */
+export interface TourStep {
+    /**
+     * The element this step points at, as a CSS selector or a ref. A step with
+     * no target renders centred and spotlights nothing — that is how a tour
+     * opens and closes.
+     * @default undefined — the step is centred, with no spotlight and no anchoring.
+     */
+    target?: string | React.RefObject<HTMLElement | null>;
+    /**
+     * Short name for the step, announced to screen readers alongside its
+     * position. Purely for the announcement — render the visible heading with
+     * `TourTitle`.
+     * @default undefined — only the position ("Step 2 of 5") is announced.
+     */
+    title?: string;
+    /**
+     * Side of the target this step's content is placed against, fed straight to
+     * the shared popper layer. `start`/`end` are logical and mirror under RTL.
+     * @default undefined — falls back to `TourContent`'s own `side`, which defaults to `bottom`.
+     */
+    placement?: Side;
+    /**
+     * Alignment along `placement`.
+     * @default undefined — falls back to `TourContent`'s own `align`, which defaults to `center`.
+     */
+    align?: Align;
+    /**
+     * How this step presents itself. `dialog` forces centred content even with a
+     * target set; the other two anchor.
+     * @default undefined — anchored when the step has a target, centred when it does not.
+     */
+    type?: TourStepType;
+}
+/** @internal Shared state distributed from {@link Tour} to its parts via context. Not part of the public API. */
+export interface TourContextValue {
+    steps: TourStep[];
+    step: number;
+    total: number;
+    activeStep: TourStep | undefined;
+    open: boolean;
+    /** True when the active step's content is positioned against a resolved target rather than centred. */
+    anchored: boolean;
+    target: HTMLElement | null;
+    spotlightStyle: React.CSSProperties;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+    contentId: string;
+    titleId: string;
+    descriptionId: string;
+    closeOnEscape: boolean;
+    closeOnInteractOutside: boolean;
+    setOpen: (open: boolean) => void;
+    goTo: (index: number) => void;
+    next: () => void;
+    prev: () => void;
+    skip: () => void;
+    complete: () => void;
+}
+/** Props for the {@link Tour} root. */
+export interface TourProps {
+    /**
+     * The trigger and portal, typically — the tour's own DOM (backdrop,
+     * spotlight, content) is rendered by {@link TourPortal} elsewhere.
+     * @default undefined — renders nothing if omitted.
+     */
+    children?: React.ReactNode;
+    /**
+     * The ordered steps. Required: a tour with no steps has nothing to show, and
+     * the array's length is what "Step 2 of 5" counts against.
+     */
+    steps: TourStep[];
+    /**
+     * Whether the tour is running, for controlled usage. Pair with `onOpenChange`.
+     * @default undefined — uncontrolled, tracks its own open state internally.
+     */
+    open?: boolean;
+    /**
+     * Whether the tour is running on mount, for uncontrolled usage.
+     * @default false — the tour waits for a trigger, so a first-visit tour is started deliberately rather than on every render.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Fires with the new open state whenever the tour starts or ends, controlled or not.
+     * @default undefined — no-op if omitted.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Index of the active step, for controlled usage. Pair with `onStepChange`.
+     * @default undefined — uncontrolled, tracks the index itself.
+     */
+    step?: number;
+    /**
+     * Index the tour starts on, for uncontrolled usage. Useful for resuming a
+     * tour the user abandoned.
+     * @default 0
+     */
+    defaultStep?: number;
+    /**
+     * Fires with the new index whenever the active step changes, controlled or
+     * not. Not fired on completion or skip — those have their own callbacks.
+     * @default undefined — no-op if omitted.
+     */
+    onStepChange?: (step: number) => void;
+    /**
+     * Fires when the user advances past the last step. The tour closes either
+     * way; this is where you record that the user has seen it.
+     * @default undefined — the tour still closes, it just tells nobody.
+     */
+    onComplete?: () => void;
+    /**
+     * Fires when the tour ends early — the skip or close trigger, or Escape.
+     * @default undefined — the tour still closes, it just tells nobody.
+     */
+    onSkip?: () => void;
+    /**
+     * Whether pressing Escape ends the tour the same way skipping does.
+     * @default true — Escape must always get a user out of a modal layer; set `false` only when the tour genuinely cannot be abandoned, and then provide another way out.
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Whether a pointer-down outside the content skips the tour.
+     * @default false — during a tour an outside click is almost always a misclick on the very UI being explained, and losing the tour to it is worse than ignoring it.
+     */
+    closeOnInteractOutside?: boolean;
+    /**
+     * Pixels of breathing room added around the target on every side when the
+     * spotlight geometry is published.
+     * @default 8 — the cutout clears the target's own focus ring instead of clipping it.
+     */
+    spotlightPadding?: number;
+    /**
+     * How long, in milliseconds, to keep polling for a step's target before
+     * giving up on it. Covers targets that mount late — a lazy route, a panel
+     * that opens on the previous step's action.
+     * @default 2000 — long enough for a lazy chunk to land, short enough that a genuinely absent target does not strand the tour.
+     */
+    targetTimeout?: number;
+    /**
+     * Fires when a step's target never appeared within `targetTimeout`. The tour
+     * then skips forward rather than rendering an unanchored popup.
+     * @default undefined — the step is still skipped, it just tells nobody.
+     */
+    onStepTargetMissing?: (index: number, step: TourStep) => void;
+    /**
+     * Builds the string announced to screen readers on every step change.
+     * Override it to translate, or to include more of the step than its title.
+     * @default undefined — announces the step's `title` (when set) followed by "Step {n} of {total}", in English.
+     */
+    getAnnouncement?: (step: TourStep, index: number, total: number) => string;
+}
+/** Props for {@link TourPortal}, which teleports the tour's layer to `document.body`. */
+export interface TourPortalProps extends PortalProps {
+    /**
+     * Render the portal even while the tour is closed, instead of unmounting it.
+     * Useful for animation libraries that need the outgoing layer present in the
+     * DOM during an exit transition.
+     * @default false
+     */
+    forceMount?: boolean;
+}
+/** Props for {@link TourBackdrop}, the dimming layer with the spotlight cutout. */
+export interface TourBackdropProps extends PrimitivePropsWithRef<'div'> {
+    /**
+     * Keep the backdrop mounted even while the tour is closed.
+     * @default false
+     */
+    forceMount?: boolean;
+}
+/** Props for {@link TourSpotlight}, the highlight box over the active step's target. */
+export interface TourSpotlightProps extends PrimitivePropsWithRef<'div'> {
+    /**
+     * Keep the spotlight mounted even while the tour is closed. It still renders
+     * nothing when the active step has no target — there is nothing to spotlight.
+     * @default false
+     */
+    forceMount?: boolean;
+}
+/**
+ * Props for {@link TourContent}, the active step's panel. Extends the shared
+ * popper positioning props (`side`, `align`, `sideOffset`, `alignOffset`,
+ * `avoidCollisions`, `collisionPadding`, `collisionBoundary`), which act as
+ * the defaults each step's own `placement`/`align` override.
+ */
+export interface TourContentProps extends PopperContentProps {
+    /**
+     * Keep the panel mounted even while the tour is closed.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Fires when Escape is pressed while the tour is open. Call
+     * `event.preventDefault()` to stop it from skipping the tour, regardless of
+     * `closeOnEscape`.
+     * @default undefined — no-op if omitted.
+     */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /**
+     * Fires on pointer-down outside the content. Call `event.preventDefault()`
+     * to stop it from skipping the tour when `closeOnInteractOutside` is set.
+     * @default undefined — no-op if omitted.
+     */
+    onPointerDownOutside?: (event: PointerEvent) => void;
+    /**
+     * Fires when focus moves outside the content. Reported only — a tour never
+     * ends on focus alone, since moving focus into the UI being explained is the
+     * point. Receives a cancelable stand-in carrying the original `focusin` as
+     * its `detail`.
+     * @default undefined — no-op if omitted.
+     */
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    /**
+     * Fires for either kind of outside interaction, immediately before the
+     * specific handler above and with the same event.
+     * @default undefined — no-op if omitted.
+     */
+    onInteractOutside?: (event: InteractOutsideEvent) => void;
+}
+/** Props for {@link TourTrigger}, the button that starts the tour. */
+export interface TourTriggerProps extends PrimitivePropsWithRef<'button'> {
+}
+/** Props for {@link TourArrow}, the arrow pointing from the content back at the target. */
+export interface TourArrowProps extends PrimitivePropsWithRef<'span'> {
+}
+/** Props for {@link TourTitle}, the active step's accessible name. */
+export interface TourTitleProps extends PrimitivePropsWithRef<'h2'> {
+}
+/** Props for {@link TourDescription}, the active step's accessible description. */
+export interface TourDescriptionProps extends PrimitivePropsWithRef<'p'> {
+}
+/** Props for {@link TourProgressText}, the visible "Step 2 of 5" line. */
+export interface TourProgressTextProps extends PrimitivePropsWithRef<'p'> {
+    /**
+     * Builds the visible progress string from the zero-based index and the total.
+     * @default undefined — renders "Step {index + 1} of {total}" in English.
+     */
+    format?: (index: number, total: number) => string;
+}
+/** Props for {@link TourNextTrigger}, which advances the tour. */
+export interface TourNextTriggerProps extends PrimitivePropsWithRef<'button'> {
+}
+/** Props for {@link TourPrevTrigger}, which steps the tour back. */
+export interface TourPrevTriggerProps extends PrimitivePropsWithRef<'button'> {
+}
+/** Props for {@link TourSkipTrigger}, which ends the tour early. */
+export interface TourSkipTriggerProps extends PrimitivePropsWithRef<'button'> {
+}
+/** Props for {@link TourCloseTrigger}, the dismiss affordance. */
+export interface TourCloseTriggerProps extends PrimitivePropsWithRef<'button'> {
+}