@overvis/hmi-workspace-ui 0.0.0-stage → 0.1.1

package/dist/src/ui/content-overlay/region.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from "react";
+interface ContentOverlayContextValue {
+    container: HTMLElement | null;
+    registerContainer: (node: HTMLElement | null) => void;
+    acquire: () => () => void;
+    lockCount: number;
+}
+export declare function useOptionalContentOverlay(): ContentOverlayContextValue | null;
+/** Holds the underlay inert for as long as this component is mounted (open popup). */
+export declare function useContentOverlayLock(): void;
+/**
+ * Scope for Dialog/Sheet portals. Wrap host chrome (header) so dialogs opened there still
+ * portal into the page `ContentOverlayRegion` instead of `document.body`.
+ */
+export declare function ContentOverlayProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Dialogs and sheets opened inside portal to the document body and cover the whole window
+ * instead of the nearest `ContentOverlayRegion`. For viewers that need more room than a narrow
+ * region gives, such as a full-window image preview. Open them with `modal` so the page behind
+ * stays out of focus.
+ */
+export declare function WindowOverlayScope({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Containing block for Dialog/Sheet portals. Must sit under `ContentOverlayProvider`.
+ * Nest another provider around a second region (assistant panel) so that region does not
+ * replace the page container.
+ */
+export declare function ContentOverlayRegion({ children, className, underlayClassName, }: {
+    children: ReactNode;
+    className?: string;
+    underlayClassName?: string;
+}): import("react").JSX.Element;
+export {};

package/dist/src/ui/content-overlay/root.d.ts

@@ -0,0 +1,3 @@
+import type { DialogRootProps } from "@base-ui/react/dialog";
+/** Default `modal={false}` and ignore dismissals that target host chrome. */
+export declare function useContentOverlayDialogRoot(props: DialogRootProps): DialogRootProps;

package/dist/src/ui/content-overlay/tab-wrap.d.ts

@@ -0,0 +1,6 @@
+/** Cycle Tab inside `root` while it has focus. Clicks outside are unaffected. */
+export declare function wrapTabInsideRoot(event: {
+    key: string;
+    shiftKey: boolean;
+    preventDefault: () => void;
+}, root: HTMLElement): void;

package/dist/src/ui/context-menu.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { ContextMenu as ContextMenuPrimitive } from "@base-ui/react/context-menu";
+declare function ContextMenu({ ...props }: ContextMenuPrimitive.Root.Props): React.JSX.Element;
+declare function ContextMenuTrigger({ className, ...props }: ContextMenuPrimitive.Trigger.Props): React.JSX.Element;
+declare function ContextMenuContent({ className, align, alignOffset, side, sideOffset, ...props }: ContextMenuPrimitive.Popup.Props & Pick<ContextMenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function ContextMenuGroup({ ...props }: ContextMenuPrimitive.Group.Props): React.JSX.Element;
+declare function ContextMenuLabel({ className, inset, ...props }: ContextMenuPrimitive.GroupLabel.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function ContextMenuItem({ className, inset, variant, ...props }: ContextMenuPrimitive.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function ContextMenuSub({ ...props }: ContextMenuPrimitive.SubmenuRoot.Props): React.JSX.Element;
+declare function ContextMenuSubTrigger({ className, inset, children, ...props }: ContextMenuPrimitive.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function ContextMenuSubContent({ ...props }: React.ComponentProps<typeof ContextMenuContent>): React.JSX.Element;
+declare function ContextMenuCheckboxItem({ className, children, checked, inset, ...props }: ContextMenuPrimitive.CheckboxItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function ContextMenuRadioGroup({ ...props }: ContextMenuPrimitive.RadioGroup.Props): React.JSX.Element;
+declare function ContextMenuRadioItem({ className, children, inset, ...props }: ContextMenuPrimitive.RadioItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: ContextMenuPrimitive.Separator.Props): React.JSX.Element;
+declare function ContextMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

package/dist/src/ui/data-table.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from "react";
+import { type Column, type ColumnDef, type ReactTable, type RowData, type TableOptions } from "@tanstack/react-table";
+declare const dataTableFeatures: {
+    columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+    columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+    rowSortingFeature: import("@tanstack/react-table").TableFeature;
+    filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+};
+type DataTableFeatures = typeof dataTableFeatures;
+type DataTableColumnDef<TData extends RowData> = ColumnDef<DataTableFeatures, TData>;
+type DataTableInstance<TData extends RowData> = ReactTable<DataTableFeatures, TData>;
+type DataTableOptions<TData extends RowData> = Omit<TableOptions<DataTableFeatures, TData>, "columns" | "data" | "features">;
+type DataTableProps<TData extends RowData> = DataTableOptions<TData> & {
+    columns: DataTableColumnDef<TData>[];
+    data: TData[];
+    empty?: ReactNode;
+    toolbar?: ReactNode | ((table: DataTableInstance<TData>) => ReactNode);
+};
+declare function DataTable<TData extends RowData>({ columns, data, empty, toolbar, ...options }: DataTableProps<TData>): import("react").JSX.Element;
+declare function DataTableColumnHeader<TData extends RowData>({ column, children, }: {
+    column: Column<DataTableFeatures, TData>;
+    children: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+declare function DataTableColumnVisibility<TData extends RowData>({ table, }: {
+    table: DataTableInstance<TData>;
+}): import("react").JSX.Element;
+declare function DataTableToolbar({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataTablePagination<TData extends RowData>({ table, }: {
+    table: DataTableInstance<TData>;
+}): import("react").JSX.Element;
+export { DataTable, DataTableColumnHeader, DataTableColumnVisibility, DataTablePagination, DataTableToolbar, };
+export type { DataTableColumnDef, DataTableInstance, DataTableOptions, DataTableProps };

package/dist/src/ui/date-time-picker.d.ts

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { Input } from "./input.js";
+type DateTimePickerProps = Omit<React.ComponentProps<typeof Input>, "onChange" | "type" | "value"> & {
+    onValueChange: (value: string) => void;
+    optional?: boolean;
+    value: string;
+};
+interface DateTimeRange {
+    from: string;
+    to: string;
+}
+type DateTimeDraftStatus = "valid" | "incomplete" | "invalid";
+interface DateTimeDraftState {
+    draft: string;
+    status: DateTimeDraftStatus;
+}
+declare function dateTimeDraftState(value: string, optional?: boolean): DateTimeDraftState;
+interface DateTimeRangePickerProps {
+    className?: string;
+    disabled?: boolean;
+    onValueChange: (value: DateTimeRange) => void;
+    optional?: boolean;
+    value: DateTimeRange;
+}
+declare function combineDateAndTime(date: Date, time: string): string | null;
+declare function isDateTimeRangeReversed(value: DateTimeRange): boolean;
+declare function DateTimePicker({ value, onValueChange, className, placeholder, disabled, id, optional, ...props }: DateTimePickerProps): React.JSX.Element;
+declare function DateTimeRangePicker({ value, onValueChange, className, disabled, optional, }: DateTimeRangePickerProps): React.JSX.Element;
+export { DateTimePicker, DateTimeRangePicker, combineDateAndTime, dateTimeDraftState, isDateTimeRangeReversed, };
+export type { DateTimePickerProps, DateTimeRange, DateTimeRangePickerProps };

package/dist/src/ui/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+declare function Dialog(props: DialogPrimitive.Root.Props): React.JSX.Element;
+declare function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props): React.JSX.Element;
+declare function DialogPortal({ ...props }: DialogPrimitive.Portal.Props): React.JSX.Element | null;
+declare function DialogClose({ ...props }: DialogPrimitive.Close.Props): React.JSX.Element;
+declare function DialogOverlay({ className, backdropBlur, ...props }: DialogPrimitive.Backdrop.Props & {
+    backdropBlur?: boolean;
+}): React.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, backdropBlur, onKeyDown, ...props }: DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+    /** Backdrop blur over canvases is expensive; the report editor turns this off. */
+    backdropBlur?: boolean;
+}): React.JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogFooter({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props): React.JSX.Element;
+declare function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props): React.JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

package/dist/src/ui/direction.d.ts

@@ -0,0 +1,3 @@
+declare const DirectionProvider: import("react").FC<import("@base-ui/react").DirectionProviderProps>;
+declare function useDirection(): import("@base-ui/react").TextDirection;
+export { DirectionProvider, useDirection };

package/dist/src/ui/drawer.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { Drawer as DrawerPrimitive } from "@base-ui/react/drawer";
+type DrawerProps = Omit<DrawerPrimitive.Root.Props, "modal"> & {
+    showSwipeHandle?: boolean;
+};
+declare function Drawer({ showSwipeHandle, snapPoints, swipeDirection, onOpenChange, ...props }: DrawerProps): React.JSX.Element;
+declare function DrawerTrigger({ ...props }: DrawerPrimitive.Trigger.Props): React.JSX.Element;
+declare function DrawerPortal({ ...props }: DrawerPrimitive.Portal.Props): React.JSX.Element | null;
+declare function DrawerClose({ ...props }: DrawerPrimitive.Close.Props): React.JSX.Element;
+declare function DrawerOverlay({ className, ...props }: DrawerPrimitive.Backdrop.Props): React.JSX.Element;
+declare function DrawerSwipeHandle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerContent({ className, children, onKeyDown, ...props }: DrawerPrimitive.Popup.Props): React.JSX.Element;
+declare function DrawerHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerTitle({ className, ...props }: DrawerPrimitive.Title.Props): React.JSX.Element;
+declare function DrawerDescription({ className, ...props }: DrawerPrimitive.Description.Props): React.JSX.Element;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerSwipeHandle, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };
+export type { DrawerProps };

package/dist/src/ui/dropdown-menu.d.ts

@@ -0,0 +1,29 @@
+import * as React from "react";
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+declare function DropdownMenu({ ...props }: MenuPrimitive.Root.Props): React.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props): React.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props): React.JSX.Element;
+declare function DropdownMenuContent({ align, alignOffset, side, sideOffset, className, ...props }: MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: MenuPrimitive.GroupLabel.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: MenuPrimitive.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: MenuPrimitive.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: MenuPrimitive.CheckboxItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props): React.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: MenuPrimitive.RadioItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: MenuPrimitive.Separator.Props): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/src/ui/empty.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+declare function Empty({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>): import("react").JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<"p">): import("react").JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+export { Empty, EmptyHeader, EmptyTitle, EmptyDescription, EmptyContent, EmptyMedia };

package/dist/src/ui/field.d.ts

@@ -0,0 +1,24 @@
+import { type VariantProps } from "class-variance-authority";
+import { Label } from "./label.js";
+declare function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">): import("react").JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<"legend"> & {
+    variant?: "legend" | "label";
+}): import("react").JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "responsive" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof fieldVariants>): import("react").JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): import("react").JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<"p">): import("react").JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<"div"> & {
+    children?: React.ReactNode;
+}): import("react").JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<"div"> & {
+    errors?: ({
+        message?: string;
+    } | undefined)[];
+}): import("react").JSX.Element | null;
+export { Field, FieldLabel, FieldDescription, FieldError, FieldGroup, FieldLegend, FieldSeparator, FieldSet, FieldContent, FieldTitle, };

package/dist/src/ui/gauge-bar.d.ts

@@ -0,0 +1,43 @@
+import { type ReactElement } from "react";
+/** A stretch of the bar, such as a zone, `from` and `to` in percent of its width. */
+export interface GaugeBarBand {
+    from: number;
+    to: number;
+    /** Its fill, such as `fill-emerald-500/35`. */
+    className: string;
+}
+/** A line through the bar at `position` percent, such as a threshold, with text above it. */
+export interface GaugeBarTick {
+    position: number;
+    label?: string;
+    /** Its stroke; `stroke-foreground` by default. */
+    className?: string;
+}
+/** The reading: one position, or the span of several readings, in percent, with text below it. */
+export type GaugeBarMarker = ({
+    position: number;
+} | {
+    from: number;
+    to: number;
+}) & {
+    label?: string;
+    /** Its fill and stroke; `fill-foreground stroke-foreground` by default. */
+    className?: string;
+};
+/**
+ * A horizontal bar with rounded ends at any width: optional bands such as zones, a fill from the
+ * start, ticks with labels above, and a marker for the reading with a label below. Positions are
+ * percent of the width; the caller maps values to them. The bar is decorative (`aria-hidden`), so
+ * the caller states the reading and limits as text or an accessible label.
+ */
+export declare function GaugeBar({ bands, fill, ticks, marker, className, }: {
+    bands?: readonly GaugeBarBand[];
+    /** Fills the bar from the start up to `to` percent. */
+    fill?: {
+        to: number;
+        className: string;
+    } | null;
+    ticks?: readonly GaugeBarTick[];
+    marker?: GaugeBarMarker | null;
+    className?: string;
+}): ReactElement;

package/dist/src/ui/gauge.d.ts

@@ -0,0 +1,24 @@
+import { type ReactElement } from "react";
+/** A round scale end at or above `value`: 1, 2 or 5 times a power of ten; 1 when not positive. */
+export declare function gaugeScaleMax(value: number): number;
+export type GaugeTone = "default" | "positive" | "warning" | "muted";
+/**
+ * A half-circle gauge from 0 to `max`: the arc fills to `value` and an optional tick marks
+ * `marker`, such as the period's peak. Values outside the scale are clamped; a null value leaves
+ * the arc empty. The caller formats the texts, so units and locales stay its own.
+ */
+export declare function Gauge({ value, max, marker, valueText, unitText, minLabel, maxLabel, tone, ariaLabel, className, }: {
+    value: number | null;
+    max: number;
+    marker?: number | null | undefined;
+    /** Large text in the middle, such as the formatted value. */
+    valueText: string;
+    /** Small text below the value, such as the unit. */
+    unitText?: string;
+    minLabel?: string;
+    /** Label at the scale end. Default: `max` as is. */
+    maxLabel?: string;
+    tone?: GaugeTone;
+    ariaLabel: string;
+    className?: string | undefined;
+}): ReactElement;

package/dist/src/ui/hover-card.d.ts

@@ -0,0 +1,5 @@
+import { PreviewCard as PreviewCardPrimitive } from "@base-ui/react/preview-card";
+declare function HoverCard({ ...props }: PreviewCardPrimitive.Root.Props): import("react").JSX.Element;
+declare function HoverCardTrigger({ ...props }: PreviewCardPrimitive.Trigger.Props): import("react").JSX.Element;
+declare function HoverCardContent({ className, side, sideOffset, align, alignOffset, ...props }: PreviewCardPrimitive.Popup.Props & Pick<PreviewCardPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react").JSX.Element;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/dist/src/ui/input-group.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./button.js";
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "block-end" | "block-start" | "inline-end" | "inline-start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): React.JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "icon-sm" | "icon-xs" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+}): React.JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

package/dist/src/ui/input-otp.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { OTPInput } from "input-otp";
+declare function InputOTP({ className, containerClassName, ...props }: React.ComponentProps<typeof OTPInput> & {
+    containerClassName?: string;
+}): React.JSX.Element;
+declare function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function InputOTPSlot({ index, className, ...props }: React.ComponentProps<"div"> & {
+    index: number;
+}): React.JSX.Element;
+declare function InputOTPSeparator({ ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

package/dist/src/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+export { Input };

package/dist/src/ui/item.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Separator } from "./separator.js";
+declare function ItemGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): React.JSX.Element;
+declare const itemVariants: (props?: ({
+    variant?: "default" | "muted" | "outline" | null | undefined;
+    size?: "default" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Item({ className, variant, size, render, ...props }: useRender.ComponentProps<"div"> & VariantProps<typeof itemVariants>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare const itemMediaVariants: (props?: ({
+    variant?: "default" | "icon" | "image" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function ItemMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>): React.JSX.Element;
+declare function ItemContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+declare function ItemActions({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Item, ItemMedia, ItemContent, ItemActions, ItemGroup, ItemSeparator, ItemTitle, ItemDescription, ItemHeader, ItemFooter, };

package/dist/src/ui/kbd.d.ts

@@ -0,0 +1,3 @@
+declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): import("react").JSX.Element;
+declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+export { Kbd, KbdGroup };

package/dist/src/ui/label.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Label({ className, ...props }: React.ComponentProps<"label">): React.JSX.Element;
+export { Label };

package/dist/src/ui/marker.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+declare const markerVariants: (props?: ({
+    variant?: "border" | "default" | "separator" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Marker({ className, variant, render, ...props }: useRender.ComponentProps<"div"> & VariantProps<typeof markerVariants>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function MarkerIcon({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function MarkerContent({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { Marker, MarkerIcon, MarkerContent, markerVariants };

package/dist/src/ui/menubar.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+import { Menubar as MenubarPrimitive } from "@base-ui/react/menubar";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger } from "./dropdown-menu.js";
+declare function Menubar({ className, ...props }: MenubarPrimitive.Props): React.JSX.Element;
+declare function MenubarMenu({ ...props }: React.ComponentProps<typeof DropdownMenu>): React.JSX.Element;
+declare function MenubarGroup({ ...props }: React.ComponentProps<typeof DropdownMenuGroup>): React.JSX.Element;
+declare function MenubarTrigger({ className, ...props }: React.ComponentProps<typeof DropdownMenuTrigger>): React.JSX.Element;
+declare function MenubarContent({ className, align, alignOffset, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+declare function MenubarItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuItem>): React.JSX.Element;
+declare function MenubarCheckboxItem({ className, children, checked, inset, ...props }: MenuPrimitive.CheckboxItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function MenubarRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuRadioGroup>): React.JSX.Element;
+declare function MenubarRadioItem({ className, children, inset, ...props }: MenuPrimitive.RadioItem.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function MenubarLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuLabel> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function MenubarSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuSeparator>): React.JSX.Element;
+declare function MenubarShortcut({ className, ...props }: React.ComponentProps<typeof DropdownMenuShortcut>): React.JSX.Element;
+declare function MenubarSub({ ...props }: React.ComponentProps<typeof DropdownMenuSub>): React.JSX.Element;
+declare function MenubarSubTrigger({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuSubTrigger> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function MenubarSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuSubContent>): React.JSX.Element;
+export { Menubar, MenubarMenu, MenubarTrigger, MenubarContent, MenubarGroup, MenubarSeparator, MenubarLabel, MenubarItem, MenubarShortcut, MenubarCheckboxItem, MenubarRadioGroup, MenubarRadioItem, MenubarSub, MenubarSubTrigger, MenubarSubContent, };

package/dist/src/ui/message-history/context.d.ts

@@ -0,0 +1,51 @@
+import { type ReactNode } from "react";
+import type { MessageScope } from "./model.js";
+/** Mount once per host. Change identity to detach pending callbacks from the previous account. */
+export declare function MessageHistoryProvider({ identity, children, }: {
+    identity?: string | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Scope action feedback to the workspace that originated it, including after navigation. */
+export declare function MessageScopeProvider({ scope, children, }: {
+    scope: MessageScope;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useMessageStore(): {
+    getSnapshot: () => {
+        id: string;
+        text: string;
+        kind: "error" | "info" | "success" | "warning";
+        time: number;
+        scope: {
+            workspaceId?: string;
+            workspaceName?: string;
+            href?: string;
+        };
+        seen: boolean;
+    }[];
+    subscribe: (listener: () => void) => () => void;
+    refresh: (now?: number) => void;
+    acceptsStorageKey: (entryKey: string | null) => boolean;
+    setActive: (value: boolean) => void;
+    isActive: () => boolean;
+    add: (message: import("./model.js").HistoryMessage) => void;
+    markSeen: (ids: readonly string[]) => void;
+    clear: () => void;
+};
+export declare function useMessageScope(): {
+    workspaceId?: string;
+    workspaceName?: string;
+    href?: string;
+};
+export declare function useHistoryMessages(): {
+    id: string;
+    text: string;
+    kind: "error" | "info" | "success" | "warning";
+    time: number;
+    scope: {
+        workspaceId?: string;
+        workspaceName?: string;
+        href?: string;
+    };
+    seen: boolean;
+}[];

package/dist/src/ui/message-history/emit.d.ts

@@ -0,0 +1,27 @@
+import { toast as sonnerToast } from "sonner";
+import { type HistoryMessage, type MessageScope } from "./model.js";
+import type { MessageStore } from "./store.js";
+export declare function createHistoryToast(store: MessageStore, scope: MessageScope, show?: Pick<typeof sonnerToast, "success" | "info" | "warning" | "error">): {
+    success: (text: string, options?: MessageScope) => void;
+    info: (text: string, options?: MessageScope) => void;
+    warning: (text: string, options?: MessageScope) => void;
+    error: (text: string, options?: MessageScope) => void;
+};
+export interface NotificationToastOptions {
+    /** Showing a toast with the id of one still shown replaces it instead of adding another. */
+    readonly id?: string;
+    readonly description?: string;
+    readonly action?: {
+        readonly label: string;
+        readonly onClick: () => void;
+    };
+}
+/**
+ * Shows a toast for something the host keeps elsewhere, such as a server notification listed in
+ * its own Notifications tab, so it is not recorded in Messages.
+ */
+export declare function showNotificationToast(kind: Exclude<HistoryMessage["kind"], "success">, title: string, options?: NotificationToastOptions): void;
+export declare function dismissHistoryToasts(): void;
+export type LegacyToast = Pick<typeof sonnerToast, "success" | "info" | "warning" | "error">;
+/** Preserve Sonner options and returned IDs for existing dashboard callers. */
+export declare function createLegacyHistoryToast(store: MessageStore, scope: MessageScope, show?: LegacyToast): LegacyToast;

package/dist/src/ui/message-history/legacy-content.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+/** Record rich legacy messages from their rendered text, including custom components. */
+export declare function LegacyToastContent({ message, record, }: {
+    message: ReactNode | (() => ReactNode);
+    record: (text: string) => void;
+}): import("react").JSX.Element;

package/dist/src/ui/message-history/legacy.d.ts

@@ -0,0 +1,7 @@
+import type { MessageScope } from "./model.js";
+import { type LegacyToast } from "./emit.js";
+import { type MessageStore } from "./store.js";
+export declare function bindLegacyMessageStore(store: MessageStore): () => void;
+export declare function bindLegacyMessageScope(scope: MessageScope): () => void;
+/** Compatibility for existing dashboards. Prefer useToast to capture an action's original scope. */
+export declare const toast: LegacyToast;

package/dist/src/ui/message-history/model.d.ts

@@ -0,0 +1,22 @@
+import { Type, type Static } from "typebox";
+export declare const MessageScopeType: Type.TObject<{
+    workspaceId: Type.TOptional<Type.TString>;
+    workspaceName: Type.TOptional<Type.TString>;
+    href: Type.TOptional<Type.TString>;
+}>;
+export type MessageScope = Static<typeof MessageScopeType>;
+export declare const MessageType: Type.TObject<{
+    id: Type.TString;
+    text: Type.TString;
+    kind: Type.TUnion<[Type.TLiteral<"success">, Type.TLiteral<"info">, Type.TLiteral<"warning">, Type.TLiteral<"error">]>;
+    time: Type.TNumber;
+    scope: Type.TObject<{
+        workspaceId: Type.TOptional<Type.TString>;
+        workspaceName: Type.TOptional<Type.TString>;
+        href: Type.TOptional<Type.TString>;
+    }>;
+    seen: Type.TBoolean;
+}>;
+export type HistoryMessage = Static<typeof MessageType>;
+/** Links recorded in history must stay within the app and must never execute a URL scheme. */
+export declare function messageHref(href: string | undefined): string | undefined;

package/dist/src/ui/message-history/panel.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+/** Shared local message history; hosts may supply the server Notifications tab and unread count. */
+export declare function MessageHistoryBell({ notifications, notificationUnreadCount, }: {
+    notifications?: ReactNode;
+    notificationUnreadCount?: number;
+}): import("react").JSX.Element;

package/dist/src/ui/message-history/store.d.ts

@@ -0,0 +1,26 @@
+import { type HistoryMessage } from "./model.js";
+export declare const messageRetentionMs: number;
+export declare function createMessageStore(scope: string | undefined, storage?: Storage): {
+    getSnapshot: () => {
+        id: string;
+        text: string;
+        kind: "error" | "info" | "success" | "warning";
+        time: number;
+        scope: {
+            workspaceId?: string;
+            workspaceName?: string;
+            href?: string;
+        };
+        seen: boolean;
+    }[];
+    subscribe: (listener: () => void) => () => void;
+    refresh: (now?: number) => void;
+    acceptsStorageKey: (entryKey: string | null) => boolean;
+    setActive: (value: boolean) => void;
+    isActive: () => boolean;
+    add: (message: HistoryMessage) => void;
+    markSeen: (ids: readonly string[]) => void;
+    clear: () => void;
+};
+export type MessageStore = ReturnType<typeof createMessageStore>;
+export declare function browserMessageStorage(): Storage | undefined;

package/dist/src/ui/message-history/toast.d.ts

@@ -0,0 +1,7 @@
+/** Records and displays plain-text action feedback in the originating identity/workspace. */
+export declare function useToast(): {
+    success: (text: string, options?: import("./model.js").MessageScope) => void;
+    info: (text: string, options?: import("./model.js").MessageScope) => void;
+    warning: (text: string, options?: import("./model.js").MessageScope) => void;
+    error: (text: string, options?: import("./model.js").MessageScope) => void;
+};