@sesamehr/react-design-system 3.3.1 → 3.4.0

package/dist/Button/ButtonGroup/ButtonGroup.d.ts

@@ -0,0 +1,11 @@
+export interface ButtonGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    dataTestid?: string;
+}
+/**
+ * ButtonGroup — mirrors `@sesame/orxata-core` ButtonGroup.
+ *
+ * Welds two or more buttons into one control. The children are whatever the
+ * caller nests, and nothing here knows how many there are or what size they
+ * came in — see the stylesheet for why that last part is the whole design.
+ */
+export declare const ButtonGroup: import('react').ForwardRefExoticComponent<ButtonGroupProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Button/ButtonGroup/index.d.ts

@@ -0,0 +1 @@
+export { ButtonGroup, type ButtonGroupProps } from './ButtonGroup.tsx';

package/dist/Button/Fab/Fab.d.ts

@@ -0,0 +1,24 @@
+export interface FabProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+    /**
+     * The text beside the glyph, which is what makes the FAB extended. Leave it
+     * out and the button is a circle.
+     */
+    label?: React.ReactNode;
+    /**
+     * Hide the label and go back to a circle.
+     *
+     * The label stays in the accessibility tree — `sr-only`, not
+     * `display: none` — so a FAB that reads "Fichar" extended still reads
+     * "Fichar" collapsed. That is why `label` is wrapped rather than passed
+     * through.
+     */
+    collapsed?: boolean;
+    dataTestid: string;
+}
+/**
+ * Fab — mirrors `@sesame/orxata-core` Fab.
+ *
+ * The one floating action of a view: a circle holding an icon, optionally
+ * extended with a label beside it.
+ */
+export declare const Fab: import('react').ForwardRefExoticComponent<FabProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Button/Fab/index.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+export { Fab, type FabProps } from './Fab.tsx';
+/**
+ * `extended` is not a prop: `Fab.tsx` derives it from `label` and `collapsed`.
+ */
+export declare const fabVariants: (props?: ({
+    extended?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type FabVariants = VariantProps<typeof fabVariants>;

package/dist/Button/IconButton/IconButton.d.ts

@@ -24,7 +24,8 @@ export interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonEl
 /**
  * IconButton — mirrors `@sesame/orxata-core` IconButton.
  *
- * A button whose entire content is an icon, circular at every size. The icon
+ * A button whose entire content is an icon, a rounded square at every size
+ * with the corner growing alongside the box. The icon
  * comes from the caller as `children`; this sizes it and never picks it.
  * `asChild` renders the child element instead of a `<button>`, via
  * `@radix-ui/react-slot`.

package/dist/Button/IconButton/index.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 export { IconButton, type IconButtonProps } from './IconButton.tsx';
 /**
- * The shape half only — the radius and the four square boxes. That is all this
+ * The shape half only — the five square boxes and their corners. That is all this
  * component adds.
  *
  * The colours are `Button`'s, and not a copy of them: `IconButton.tsx` calls
@@ -14,14 +14,15 @@ export { IconButton, type IconButtonProps } from './IconButton.tsx';
  * ```
  *
  * `size: null` is cva's opt-out, and it is load-bearing: `buttonVariants`
- * defaults to `md`, which would bring `px-5`, `h-12` and `rounded-2xl` along
- * and stop the box being a square circle.
+ * defaults to `md`, which would bring `px-5` and `h-12` along and stop the box
+ * being square. Its radius would come too, and that is the quieter half of the
+ * same bug: right at `md` by coincidence and wrong at the other three steps.
  *
  * Class names, not utilities — see the long note in `../index.ts` for why a
  * utility in a variant forces the package to publish `.size-12` into the
  * consumer's cascade.
  */
 export declare const iconButtonVariants: (props?: ({
-    size?: "xs" | "sm" | "md" | "lg" | null | undefined;
+    size?: "2xs" | "xs" | "sm" | "md" | "lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export type IconButtonVariants = VariantProps<typeof iconButtonVariants>;

package/dist/Button/SplitButton/SplitButton.d.ts

@@ -0,0 +1,48 @@
+export interface SplitButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** `default` is the board's Primary. Those two are the only styles drawn. */
+    variant?: 'default' | 'outline';
+    /**
+     * The full `OxButton` scale, which the board (`1449:294`) draws in all five
+     * sizes. Every measurement comes from `OxButton` — the segment's height, its
+     * padding and its corner — so there is nothing per step in this file.
+     */
+    size?: '2xs' | 'xs' | 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    /**
+     * What a screen reader hears on the chevron. It has no text of its own, so
+     * without a name it announces as "button" and nothing else.
+     *
+     * Left alone it is the design system's own translated "More options", so this
+     * is for a caller who wants different wording — "More export formats" — not
+     * for one who wants any wording.
+     */
+    menuLabel?: string;
+    /** The rows of the dropdown. The Vue port's `menu` slot. */
+    menu?: React.ReactNode;
+    dataTestid?: string;
+}
+/**
+ * SplitButton — mirrors `@sesame/orxata-core` SplitButton.
+ *
+ * One main action with its variants behind a chevron: "Create absence" plus
+ * "Create for several people", "Export Excel" plus PDF and CSV.
+ *
+ * Two independent buttons, which is what the design's accessibility note asks
+ * for and what the composition already gives: clicking the label runs the
+ * action, clicking the chevron opens the menu, and each is its own tab stop.
+ * `OxButtonGroup` welds them; `OxDropdownMenu` brings `aria-haspopup`,
+ * `aria-expanded`, the arrow keys and the Esc that returns focus to the
+ * chevron. Nothing here reimplements any of that.
+ *
+ * Every other prop lands on the **action**, not on the group — the Vue port
+ * does the same with `inheritAttrs: false`, so `onClick` and `type="submit"`
+ * reach the left segment in both. `className` is the exception and goes to the
+ * whole control, because a caller sizing a split button means the control and
+ * not its left half.
+ *
+ * Open is held here rather than exposed, for the same reason as in Vue: the
+ * board's `Open` state paints *both* segments with the hover fill, and the left
+ * one is a sibling of the trigger — no selector reaches it from there. A
+ * controlled path would be a sixth prop and nothing asks for one.
+ */
+export declare const SplitButton: import('react').ForwardRefExoticComponent<SplitButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Button/SplitButton/index.d.ts

@@ -0,0 +1 @@
+export { SplitButton, type SplitButtonProps } from './SplitButton.tsx';

package/dist/Button/index.d.ts

@@ -2,6 +2,6 @@ import { VariantProps } from 'class-variance-authority';
 export { Button, type ButtonProps } from './Button.tsx';
 export declare const buttonVariants: (props?: ({
     variant?: "link" | "default" | "destructive" | "success" | "outline" | "secondary" | "ghost" | null | undefined;
-    size?: "icon" | "xs" | "sm" | "md" | "lg" | null | undefined;
+    size?: "icon" | "2xs" | "xs" | "sm" | "md" | "lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export type ButtonVariants = VariantProps<typeof buttonVariants>;

package/dist/Data/Table/hooks/useTableVirtual/useTableVirtual.types.d.ts

@@ -26,7 +26,7 @@ export interface UseTableVirtualOptions {
      * This is what turns a scroll position into a row index, so it is worth
      * getting right: the error is paid on every row crossed, which is nothing at
      * one click of the wheel and hundreds of rows after a flick. The default,
-     * 52px, is `--table-row-height` on `.oxTableRoot` — the minimum a row's cells
+     * 52px, is `--ox-table-row-height` on `.oxTableRoot` — the minimum a row's cells
      * give it with plain text in them. (Not `TableRow`'s own CSS: `height` on a
      * `<tr>` is ignored by the table layout algorithm.) Rows with an avatar or two
      * lines of text are taller, and those tables should say so here.

package/dist/Display/Badge/Badge.d.ts

@@ -1,7 +1,9 @@
 import { BadgeVariants } from './index.ts';
-export interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'color'> {
     /** How big the counter is. `sm` is the bare dot and takes no content. */
     size?: BadgeVariants['size'];
+    /** Which fill it takes. Only the colour changes; the shape does not. */
+    color?: BadgeVariants['color'];
     dataTestid: string;
 }
 /** Badge — mirrors `@sesame/orxata-core` Badge: a count, or a bare dot. */

package/dist/Display/Badge/index.d.ts

@@ -3,13 +3,15 @@ export { Badge, type BadgeProps } from './Badge.tsx';
 /**
  * A count, or a bare dot. Not a labelled pill.
  *
- * Figma's `Badges` set varies on one axis — size — and nothing else: `sm` is a
- * 6px dot with no content, `md` a 16px circle and `lg` a 22px one, all of them
- * `error` red with white text. The five colour variants this used to carry came
- * from shadcn's Badge and were never in the design; a labelled pill is `Chip`
- * or `StatusBadge`, both of which Figma does draw.
+ * Figma's `Badge` set is two axes and no states. Size: `sm` is a 6px dot with
+ * no content, `md` a 16px circle and `lg` a 22px one. Colour: `error` for
+ * notifications, `brand` for what is new, `neutral` for an informational
+ * count — a fill and nothing else, since shape, type and padding are identical
+ * across the three. A labelled pill is `Chip` or `StatusBadge`, both of which
+ * Figma draws as components of their own.
  */
 export declare const badgeVariants: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
+    color?: "error" | "neutral" | "brand" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/Display/Mention/Mention.d.ts

@@ -0,0 +1,28 @@
+export interface MentionProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+    /** Whether the person mentioned is the reader, which repaints it amber */
+    personal?: boolean;
+    /** Render as the child element instead of a `<button>` (Radix Slot). */
+    asChild?: boolean;
+}
+/**
+ * Mention — mirrors `@sesame/orxata-core` Mention.
+ *
+ * There is deliberately no `href` prop and no `onClick`-or-`href` pair. The
+ * brief was "a link and an event", but those are two different elements and only
+ * the caller knows which one they are after: an `<a href>` gets cmd-click,
+ * middle-click, "copy link address" and the status bar, none of which a handler
+ * reproduces, while a `<button>` is right when there is no address to go to.
+ * `asChild` is that choice made once — it is what the Vue side spells `as` /
+ * `as-child`, and the `as` prop is not ported.
+ *
+ *   <Mention asChild><a href={`/people/${id}`}>@{name}</a></Mention>
+ *   <Mention onClick={openProfile}>@{name}</Mention>
+ *   <Mention asChild><span>@{name}</span></Mention>
+ *
+ * A `<button>` is the default because every state the board draws — hover and
+ * focus included — is an interactive one, and of the two wrong defaults, a
+ * `<span>` a caller hangs `onClick` on is the one that ships a control the
+ * keyboard cannot reach. The last form above is static highlighted text, and the
+ * stylesheet drops its pointer cursor and hover fill to say so.
+ */
+export declare const Mention: import('react').ForwardRefExoticComponent<MentionProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Display/Mention/index.d.ts

@@ -0,0 +1,6 @@
+import { VariantProps } from 'class-variance-authority';
+export { Mention, type MentionProps } from './Mention.tsx';
+export declare const mentionVariants: (props?: ({
+    personal?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type MentionVariants = VariantProps<typeof mentionVariants>;

package/dist/Display/PlayerPill/PlayerPill.d.ts

@@ -0,0 +1,11 @@
+import { PlayerPillState } from './playerPillContext.ts';
+export interface PlayerPillProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    state?: PlayerPillState;
+    children?: React.ReactNode;
+    dataTestid: string;
+}
+/**
+ * The clock-in pill — mirrors `@sesame/orxata-core` PlayerPill: the day's
+ * elapsed time and the controls to move it on.
+ */
+export declare const PlayerPill: import('react').ForwardRefExoticComponent<PlayerPillProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Display/PlayerPill/PlayerPillAction.d.ts

@@ -0,0 +1,10 @@
+import { IconButtonProps } from '../../Button/IconButton/index.ts';
+import { PlayerPillActionName } from './playerPillContext.ts';
+export interface PlayerPillActionProps extends Omit<IconButtonProps, 'aria-label' | 'variant' | 'size' | 'children' | 'asChild'> {
+    action: PlayerPillActionName;
+}
+/**
+ * One of the four round controls on the right of the pill — mirrors
+ * `@sesame/orxata-core` PlayerPillAction.
+ */
+export declare const PlayerPillAction: import('react').ForwardRefExoticComponent<PlayerPillActionProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Display/PlayerPill/PlayerPillStatus.d.ts

@@ -0,0 +1,11 @@
+export type PlayerPillStatusProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * The glyph at the head of the pill — mirrors `@sesame/orxata-core`
+ * PlayerPillStatus: a dot while the day is counting, a clock face once it is
+ * not.
+ *
+ * The dot carries the state as its accessible name: running and paused differ
+ * only in colour. The clock is `aria-hidden` instead — the readout beside it
+ * already says "Not clocked in".
+ */
+export declare const PlayerPillStatus: import('react').ForwardRefExoticComponent<PlayerPillStatusProps & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/Display/PlayerPill/PlayerPillTime.d.ts

@@ -0,0 +1,18 @@
+export interface PlayerPillTimeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Seconds banked before the current run. The whole total when paused. */
+    seconds?: number;
+    /** When the current run began. Ignored unless the pill is running. */
+    startedAt?: Date | number;
+}
+/**
+ * The readout — mirrors `@sesame/orxata-core` PlayerPillTime: `02:34:12` while
+ * there is a day to count, the words for "no day yet" when there is not.
+ *
+ * `startedAt` is read only while running: on pause a tracker folds the open
+ * stretch into `seconds` and forgets when it began, so a `startedAt` left
+ * behind must not keep adding to it.
+ *
+ * `aria-live="off"` is spelled out rather than left implicit — a live region
+ * here would read the whole day out once a second for eight hours.
+ */
+export declare const PlayerPillTime: import('react').ForwardRefExoticComponent<PlayerPillTimeProps & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/Display/PlayerPill/index.d.ts

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+export { PlayerPill, type PlayerPillProps } from './PlayerPill.tsx';
+export { PlayerPillAction, type PlayerPillActionProps, } from './PlayerPillAction.tsx';
+export { PlayerPillStatus, type PlayerPillStatusProps, } from './PlayerPillStatus.tsx';
+export { PlayerPillTime, type PlayerPillTimeProps } from './PlayerPillTime.tsx';
+export { MISSING_PLAYER_PILL, PlayerPillContext, usePlayerPill, type PlayerPillActionName, type PlayerPillContextValue, type PlayerPillState, } from './playerPillContext.ts';
+export { formatElapsed, useElapsedSeconds, type UseElapsedSecondsOptions, } from './useElapsedSeconds.ts';
+/**
+ * The state classes carry the pill's fill and its text colour, and they sit on
+ * the root so the dot, the clock glyph and the readout inherit that colour.
+ */
+export declare const playerPillVariants: (props?: ({
+    state?: "paused" | "running" | "stopped" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type PlayerPillVariants = VariantProps<typeof playerPillVariants>;

package/dist/Display/PlayerPill/playerPillContext.d.ts

@@ -0,0 +1,16 @@
+/** Which of the three the pill is in. The application owns the transitions. */
+export type PlayerPillState = 'running' | 'paused' | 'stopped';
+/** The four controls. Here, as in the Vue package, rather than on the component. */
+export type PlayerPillActionName = 'start' | 'pause' | 'resume' | 'stop';
+export interface PlayerPillContextValue {
+    state: PlayerPillState;
+    /** The root's `dataTestid`, so every part derives its own from it. */
+    dataTestid: string;
+}
+export declare const PlayerPillContext: import('react').Context<PlayerPillContextValue | null>;
+export declare const MISSING_PLAYER_PILL = "A PlayerPill part has to be rendered inside OxPlayerPill.";
+/**
+ * Throws rather than defaulting: every part reads the state to decide whether it
+ * renders, so a silent default would put a clock-in button on a running pill.
+ */
+export declare const usePlayerPill: () => PlayerPillContextValue;

package/dist/Display/PlayerPill/useElapsedSeconds.d.ts

@@ -0,0 +1,18 @@
+export interface UseElapsedSecondsOptions {
+    /** Everything banked before the current run. The whole total when paused. */
+    seconds: number;
+    /** When the current run began. Only read while `running`. */
+    startedAt: Date | number | undefined;
+    running: boolean;
+}
+/** `02:34:12`. Hours are not wrapped — a 100-hour total renders three digits. */
+export declare const formatElapsed: (seconds: number) => string;
+/**
+ * A running total of seconds — mirrors `@sesame/orxata-core` useElapsedSeconds.
+ * Recomputed from `Date.now()` on every tick rather than counted up: timers
+ * fire late under load and a background tab is throttled to roughly one wake a
+ * minute, so an incremented counter comes back minutes behind while a derived
+ * one lands on the right number. The timeout targets the next whole second of
+ * the displayed value, not a flat 1000ms.
+ */
+export declare const useElapsedSeconds: ({ seconds, startedAt, running, }: UseElapsedSecondsOptions) => number;

package/dist/Display/Tag/Tag.d.ts

@@ -0,0 +1,17 @@
+import { TagVariants } from './index.ts';
+/**
+ * `color` has to be omitted before it is redeclared: React's `HTMLAttributes`
+ * carries HTML's deprecated presentational `color` attribute as `string`, and
+ * the variant union will not widen to it.
+ */
+export interface TagProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'color'> {
+    /** Which category this is. The hue is the category's identity. */
+    color?: TagVariants['color'];
+    /** How loudly it is painted: a tint behind dark text, or the full hue. */
+    variant?: TagVariants['variant'];
+    /** How tall it is. Both sizes set the same 12px type. */
+    size?: TagVariants['size'];
+    dataTestid: string;
+}
+/** A category a thing belongs to, told apart by its hue. */
+export declare const Tag: import('react').ForwardRefExoticComponent<TagProps & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/Display/Tag/index.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+export { Tag, type TagProps } from './Tag.tsx';
+/**
+ * A category a thing belongs to, told apart by its hue.
+ *
+ * The design calls the second axis `Style`; it is `variant` here because a prop
+ * named `style` would eat the caller's inline styles.
+ */
+export declare const tagVariants: (props?: ({
+    color?: "blue" | "fuchsia" | "green" | "indigo" | "lime" | "orange" | "pink" | "purple" | "red" | "teal" | "violet" | "yellow" | "brand" | "zinc" | "amber" | "sky" | null | undefined;
+    variant?: "solid" | "soft" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type TagVariants = VariantProps<typeof tagVariants>;

package/dist/Feedback/Alert/AlertDescription.d.ts

@@ -1,3 +1,3 @@
 export type AlertDescriptionProps = React.HTMLAttributes<HTMLDivElement>;
-/** AlertDescription — hidden when a collapsible Alert is closed. */
+/** AlertDescription — folds away when a collapsible Alert is closed. */
 export declare const AlertDescription: import('react').ForwardRefExoticComponent<AlertDescriptionProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Alert/alert-context.d.ts

@@ -1,4 +1,4 @@
-export type AlertVariant = 'warning' | 'error' | 'info' | 'success';
+export type AlertVariant = 'warning' | 'error' | 'info' | 'success' | 'muted';
 export interface AlertContextValue {
     variant: AlertVariant;
     isDismissed: boolean;

package/dist/Feedback/Bullet/index.d.ts

@@ -2,6 +2,6 @@ import { VariantProps } from 'class-variance-authority';
 export { Bullet, type BulletProps } from './Bullet.tsx';
 export declare const bulletVariants: (props?: ({
     size?: "24" | "16" | "12" | "8" | null | undefined;
-    color?: "active" | "info" | "warning" | "neutral" | null | undefined;
+    color?: "active" | "error" | "info" | "warning" | "neutral" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export type BulletVariants = VariantProps<typeof bulletVariants>;

package/dist/Feedback/Dialog/DialogFullScreenContent.d.ts

@@ -0,0 +1,33 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export interface DialogFullScreenContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    showCloseButton?: boolean;
+    /** Content of the top bar, beside the close button — usually a DialogTitle. */
+    header?: React.ReactNode;
+    /** Content of the left sidebar; the sidebar is dropped when it is absent. */
+    sidebarLeft?: React.ReactNode;
+    /** Content of the right sidebar; the sidebar is dropped when it is absent. */
+    sidebarRight?: React.ReactNode;
+    /** Content of the footer bar; the footer is dropped when it is absent. */
+    footer?: React.ReactNode;
+}
+/**
+ * DialogFullScreenContent — mirrors `@sesame/orxata-core`
+ * DialogFullScreenContent. The third panel shape of `Dialog`, beside
+ * `DialogContent` and `DialogTwoPanelContent`: a surface that takes the whole
+ * viewport for a long flow — a wizard, an editor with a preview, a settings
+ * screen.
+ *
+ * It is a content shape and not a component of its own because everything
+ * outside the panel is unchanged: the same `Dialog.Root`, the same portal,
+ * overlay, title, description, close button and `orxata.dialog.close`. What
+ * differs is geometry, and geometry is exactly the axis the two existing
+ * shapes already differ on.
+ *
+ * Unlike them it owns its regions rather than styling whatever the caller
+ * drops in `children`, because the top bar is a fixed 56px strip with the
+ * close button *inside* it and the body is a three-column row. A region is
+ * rendered only when its prop is filled, which is how the board's
+ * `Show left sidebar` / `Show right sidebar` / `Show stepper` toggles are
+ * expressed without a prop for each.
+ */
+export declare const DialogFullScreenContent: import('react').ForwardRefExoticComponent<DialogFullScreenContentProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Dialog/index.d.ts

@@ -5,4 +5,5 @@ export { DialogTitle, type DialogTitleProps } from './DialogTitle.tsx';
 export { DialogDescription, type DialogDescriptionProps, } from './DialogDescription.tsx';
 export { DialogOverlay, type DialogOverlayProps } from './DialogOverlay.tsx';
 export { DialogTwoPanelContent, type DialogTwoPanelContentProps, } from './DialogTwoPanelContent.tsx';
+export { DialogFullScreenContent, type DialogFullScreenContentProps, } from './DialogFullScreenContent.tsx';
 export { Trigger as DialogTrigger, Close as DialogClose, } from '@radix-ui/react-dialog';

package/dist/Feedback/EmptyState/EmptyState.d.ts

@@ -0,0 +1,26 @@
+import { EmptyStateVariants } from './index.ts';
+/**
+ * What a view says when it has nothing to show. Mirrors `@sesame/orxata-core`
+ * EmptyState.
+ */
+export interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** `page` fills the view; `inline` shrinks the stack for a card or a table. */
+    variant?: EmptyStateVariants['variant'];
+    /**
+     * The glyph in the circle. Defaults to a generic inbox; pass `null` to drop
+     * the circle along with it.
+     */
+    icon?: React.ReactNode;
+    /** The heading. Bring your own level — only the page knows which one fits. */
+    title?: React.ReactNode;
+    /** One line explaining what would be here. */
+    description?: React.ReactNode;
+    /** Whatever gets the user out of the empty state. */
+    actions?: React.ReactNode;
+    /** The ways to get started, as `OxEmptyStateOption` cards. */
+    options?: React.ReactNode;
+    /** A quieter way out: help, documentation, who to ask. */
+    link?: React.ReactNode;
+    dataTestid: string;
+}
+export declare const EmptyState: import('react').ForwardRefExoticComponent<EmptyStateProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/EmptyState/EmptyStateOption/EmptyStateOption.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One of the ways to get started, for the onboarding empty state. Mirrors
+ * `@sesame/orxata-core` EmptyStateOption.
+ */
+export interface EmptyStateOptionProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'title'> {
+    /** Paints the brand border and announces the card as pressed. */
+    selected?: boolean;
+    /** The glyph above the text. Defaults to a generic "new folder". */
+    icon?: React.ReactNode;
+    /** What this option is. */
+    title?: React.ReactNode;
+    /** One line about what choosing it does. */
+    description?: React.ReactNode;
+    dataTestid: string;
+}
+export declare const EmptyStateOption: import('react').ForwardRefExoticComponent<EmptyStateOptionProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Feedback/EmptyState/EmptyStateOption/index.d.ts

@@ -0,0 +1 @@
+export { EmptyStateOption, type EmptyStateOptionProps, } from './EmptyStateOption.tsx';

package/dist/Feedback/EmptyState/index.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+export { EmptyState, type EmptyStateProps } from './EmptyState.tsx';
+/**
+ * Class names, not utilities: a utility in here would be published into the
+ * consumer's cascade.
+ */
+export declare const emptyStateVariants: (props?: ({
+    variant?: "page" | "inline" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type EmptyStateVariants = VariantProps<typeof emptyStateVariants>;

package/dist/Feedback/Toast/Toast.d.ts

@@ -0,0 +1,15 @@
+import { ToastType } from './useToast.ts';
+import * as ToastPrimitive from '@radix-ui/react-toast';
+export interface ToastProps extends Omit<React.ComponentPropsWithoutRef<typeof ToastPrimitive.Root>, 'type'> {
+    type?: ToastType;
+    dataTestid?: string;
+}
+/**
+ * Toast — mirrors `orxata-core` Toast.
+ *
+ * Not `role="alert"` on an error: Radix announces from a *separate* live
+ * region whose politeness `type` picks, so overriding `role` here would leave
+ * the real announcer on the wrong setting and change nothing a screen reader
+ * hears.
+ */
+export declare const Toast: import('react').ForwardRefExoticComponent<ToastProps & import('react').RefAttributes<HTMLLIElement>>;

package/dist/Feedback/Toast/ToastAction.d.ts

@@ -0,0 +1,12 @@
+import * as ToastPrimitive from '@radix-ui/react-toast';
+export interface ToastActionProps extends React.ComponentPropsWithoutRef<typeof ToastPrimitive.Action> {
+    dataTestid?: string;
+}
+/**
+ * ToastAction — mirrors `orxata-core` ToastAction.
+ *
+ * `altText` is what a screen reader is told instead of the button, which is
+ * gone before anyone can reach it — so it must describe a route that outlives
+ * the toast.
+ */
+export declare const ToastAction: import('react').ForwardRefExoticComponent<ToastActionProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Feedback/Toast/ToastClose.d.ts

@@ -0,0 +1,12 @@
+import * as ToastPrimitive from '@radix-ui/react-toast';
+export interface ToastCloseProps extends React.ComponentPropsWithoutRef<typeof ToastPrimitive.Close> {
+    dataTestid?: string;
+}
+/**
+ * ToastClose — mirrors `orxata-core` ToastClose.
+ *
+ * `orxata.dialog.close` and not `orxata.toast.close`: the catalogue comes from
+ * Lokalise, so a key this repository invents renders as the key itself in
+ * every language until someone adds it there. Swap it when it lands.
+ */
+export declare const ToastClose: import('react').ForwardRefExoticComponent<ToastCloseProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Feedback/Toast/ToastDescription.d.ts

@@ -0,0 +1,4 @@
+import * as ToastPrimitive from '@radix-ui/react-toast';
+export type ToastDescriptionProps = React.ComponentPropsWithoutRef<typeof ToastPrimitive.Description>;
+/** ToastDescription — mirrors `orxata-core` ToastDescription. */
+export declare const ToastDescription: import('react').ForwardRefExoticComponent<Omit<ToastPrimitive.ToastDescriptionProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Toast/ToastIcon.d.ts

@@ -0,0 +1,5 @@
+export interface ToastIconProps extends React.HTMLAttributes<HTMLDivElement> {
+    dataTestid?: string;
+}
+/** ToastIcon — renders the type's default icon, or `children` if provided. */
+export declare const ToastIcon: import('react').ForwardRefExoticComponent<ToastIconProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Toast/ToastTitle.d.ts

@@ -0,0 +1,4 @@
+import * as ToastPrimitive from '@radix-ui/react-toast';
+export type ToastTitleProps = React.ComponentPropsWithoutRef<typeof ToastPrimitive.Title>;
+/** ToastTitle — mirrors `orxata-core` ToastTitle. */
+export declare const ToastTitle: import('react').ForwardRefExoticComponent<Omit<ToastPrimitive.ToastTitleProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Toast/Toaster.d.ts

@@ -0,0 +1,24 @@
+import { ToastPosition } from './index.ts';
+import * as ToastPrimitive from '@radix-ui/react-toast';
+export interface ToasterProps extends React.ComponentPropsWithoutRef<typeof ToastPrimitive.Viewport> {
+    /** Which corner the stack is anchored to. */
+    position?: ToastPosition;
+    /** Milliseconds a toast stays up unless it asks for its own. */
+    duration?: number;
+    /** How many may be on screen at once; a newer one closes the oldest. */
+    max?: number;
+    /**
+     * Where the viewport is portalled. `body` is the default and should stay
+     * that way; the escape hatch is for a native `<dialog>`, whose top layer
+     * paints over everything in `body`.
+     */
+    to?: string | Element;
+}
+/**
+ * Toaster — mirrors `orxata-core` Toaster.
+ *
+ * Radix has no `Portal` part, so the portal is `react-dom`'s `createPortal`
+ * and it has to stay *inside* `Toast.Provider` for the viewport to read the
+ * provider's context across the boundary.
+ */
+export declare const Toaster: import('react').ForwardRefExoticComponent<ToasterProps & import('react').RefAttributes<HTMLOListElement>>;