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

package/dist/src/ui/message-scroller.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { MessageScroller as MessageScrollerPrimitive, useMessageScroller as usePrimitiveMessageScroller, useMessageScrollerScrollable as usePrimitiveMessageScrollerScrollable, useMessageScrollerVisibility as usePrimitiveMessageScrollerVisibility } from "@shadcn/react/message-scroller";
+import { Button } from "./button.js";
+declare const MessageScrollerProvider: ({ autoScroll, children, defaultScrollPosition, scrollEdgeThreshold, scrollPreviousItemPeek, scrollMargin, }: {
+    children?: React.ReactNode;
+    autoScroll?: boolean;
+    defaultScrollPosition?: import("@shadcn/react/message-scroller").MessageScrollerDefaultScrollPosition;
+    scrollEdgeThreshold?: number;
+    scrollPreviousItemPeek?: number;
+    scrollMargin?: number;
+}) => React.JSX.Element;
+declare const useMessageScroller: typeof usePrimitiveMessageScroller;
+declare const useMessageScrollerScrollable: typeof usePrimitiveMessageScrollerScrollable;
+declare const useMessageScrollerVisibility: typeof usePrimitiveMessageScrollerVisibility;
+declare function MessageScroller({ className, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Root>): React.JSX.Element;
+declare function MessageScrollerViewport({ className, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Viewport>): React.JSX.Element;
+declare function MessageScrollerContent({ className, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Content>): React.JSX.Element;
+declare function MessageScrollerItem({ className, scrollAnchor, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Item>): React.JSX.Element;
+declare function MessageScrollerButton({ direction, className, children, render, variant, size, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Button> & Pick<React.ComponentProps<typeof Button>, "variant" | "size">): React.JSX.Element;
+export { MessageScrollerProvider, MessageScroller, MessageScrollerViewport, MessageScrollerContent, MessageScrollerItem, MessageScrollerButton, useMessageScroller, useMessageScrollerScrollable, useMessageScrollerVisibility, };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function MessageGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function Message({ className, align, ...props }: React.ComponentProps<"div"> & {
+    align?: "start" | "end";
+}): React.JSX.Element;
+declare function MessageAvatar({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function MessageContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function MessageHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function MessageFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { MessageGroup, Message, MessageAvatar, MessageContent, MessageFooter, MessageHeader };

package/dist/src/ui/native-select.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+type NativeSelectProps = Omit<React.ComponentProps<"select">, "size"> & {
+    size?: "sm" | "default" | "inline";
+};
+declare function NativeSelect({ className, size, ...props }: NativeSelectProps): React.JSX.Element;
+declare function NativeSelectOption({ className, ...props }: React.ComponentProps<"option">): React.JSX.Element;
+declare function NativeSelectOptGroup({ className, ...props }: React.ComponentProps<"optgroup">): React.JSX.Element;
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };

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

@@ -0,0 +1,11 @@
+import { NavigationMenu as NavigationMenuPrimitive } from "@base-ui/react/navigation-menu";
+declare function NavigationMenu({ align, className, children, ...props }: NavigationMenuPrimitive.Root.Props & Pick<NavigationMenuPrimitive.Positioner.Props, "align">): import("react").JSX.Element;
+declare function NavigationMenuList({ className, ...props }: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.List>): import("react").JSX.Element;
+declare function NavigationMenuItem({ className, ...props }: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.Item>): import("react").JSX.Element;
+declare const navigationMenuTriggerStyle: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare function NavigationMenuTrigger({ className, children, ...props }: NavigationMenuPrimitive.Trigger.Props): import("react").JSX.Element;
+declare function NavigationMenuContent({ className, ...props }: NavigationMenuPrimitive.Content.Props): import("react").JSX.Element;
+declare function NavigationMenuPositioner({ className, side, sideOffset, align, alignOffset, ...props }: NavigationMenuPrimitive.Positioner.Props): import("react").JSX.Element;
+declare function NavigationMenuLink({ className, ...props }: NavigationMenuPrimitive.Link.Props): import("react").JSX.Element;
+declare function NavigationMenuIndicator({ className, ...props }: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.Icon>): import("react").JSX.Element;
+export { NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, navigationMenuTriggerStyle, NavigationMenuPositioner, };

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

@@ -0,0 +1,61 @@
+import * as React from "react";
+/** How urgent a notice is: a fault to fix, a degraded state to watch, or plain information. */
+type NoticeSeverity = "error" | "warning" | "info";
+/** A labelled fact shown in the notice's technical details. */
+interface NoticeCardDetail {
+    label: string;
+    value: React.ReactNode;
+}
+/**
+ * A button in the notice's action row. `href` or `render` makes it a link; while `disabled` or
+ * `pending`, a link renders as a disabled button.
+ */
+interface NoticeCardAction {
+    label: string;
+    icon?: React.ReactNode;
+    onClick?: () => void;
+    href?: string;
+    /** The element rendered in place of the button, such as a router link. */
+    render?: React.ReactElement<{
+        className?: string;
+        children?: React.ReactNode;
+    }>;
+    disabled?: boolean;
+    pending?: boolean;
+}
+interface NoticeCardProps extends Omit<React.ComponentProps<"div">, "title"> {
+    severity?: NoticeSeverity;
+    /** `compact` fits panels and narrow sections; `default` sits in a page or dashboard body. */
+    size?: "default" | "compact";
+    /** Replaces the severity's icon. */
+    icon?: React.ReactNode;
+    /** What the notice is about, such as a device, shown above the title. */
+    subject?: React.ReactNode;
+    title?: React.ReactNode;
+    /** What happened and what to do, in plain language. */
+    description?: React.ReactNode;
+    /** Technical facts, collapsed under a disclosure unless `detailsOpen` is set. */
+    details?: readonly NoticeCardDetail[];
+    detailsOpen?: boolean;
+    /** The one action that most likely resolves the notice. */
+    primaryAction?: NoticeCardAction;
+    secondaryActions?: readonly NoticeCardAction[];
+    /**
+     * Adds a Retry button: the primary action unless `primaryAction` is set. A returned promise
+     * keeps the button pending until it settles.
+     */
+    onRetry?: () => unknown;
+    /** A retry or read is under way, such as a refetching query. */
+    retrying?: boolean;
+    /** Replaces "Retry", such as "Retry connection". */
+    retryLabel?: string;
+    /** Custom action elements after the built-in ones, such as a command button. */
+    actions?: React.ReactNode;
+}
+/**
+ * A problem or status notice inside a dashboard or page: a severity badge, a title, a plain
+ * explanation, optional technical details, and a primary action ahead of secondary ones.
+ */
+declare function NoticeCard({ severity, size, icon, subject, title, description, details, detailsOpen, primaryAction, secondaryActions, onRetry, retrying, retryLabel, actions, className, children, ...props }: NoticeCardProps): React.JSX.Element;
+export { NoticeCard };
+export type { NoticeCardAction, NoticeCardDetail, NoticeCardProps, NoticeSeverity };

package/dist/src/ui/page-header.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+/**
+ * Page header: a large title with an optional leading icon, a muted description underneath, optional
+ * controls beside the title, and trailing actions. The one place on a dense page where the eye can
+ * rest; content below stays compact. Wraps on narrow screens instead of squeezing the title.
+ *
+ * `breadcrumbs` sit above the title in small muted text and name the ancestors only; the title is
+ * the current page.
+ *
+ * A separator closes the header inside its padding, so the line never reaches the edges of the
+ * page column.
+ */
+declare function PageHeader({ icon, breadcrumbs, title, description, titleActions, actions, children, className, ...props }: Omit<React.ComponentProps<"header">, "title"> & {
+    icon?: ReactNode;
+    breadcrumbs?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    titleActions?: ReactNode;
+    actions?: ReactNode;
+}): import("react").JSX.Element;
+export { PageHeader };

package/dist/src/ui/page-title.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare function PageTitle({ className, size, ...props }: React.ComponentProps<"h1"> & {
+    size?: "large" | "default" | "compact";
+}): React.JSX.Element;
+export { PageTitle };

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { Button } from "./button.js";
+declare function Pagination({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function PaginationItem({ ...props }: React.ComponentProps<"li">): React.JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<React.ComponentProps<typeof Button>, "size"> & React.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+declare function PaginationPrevious({ className, text, ...props }: React.ComponentProps<typeof PaginationLink> & {
+    text?: string;
+}): React.JSX.Element;
+declare function PaginationNext({ className, text, ...props }: React.ComponentProps<typeof PaginationLink> & {
+    text?: string;
+}): React.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, };

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { Popover as PopoverPrimitive } from "@base-ui/react/popover";
+declare function Popover({ ...props }: PopoverPrimitive.Root.Props): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: PopoverPrimitive.Trigger.Props): React.JSX.Element;
+declare function PopoverContent({ className, align, alignOffset, side, sideOffset, ...props }: PopoverPrimitive.Popup.Props & Pick<PopoverPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function PopoverTitle({ className, ...props }: PopoverPrimitive.Title.Props): React.JSX.Element;
+declare function PopoverDescription({ className, ...props }: PopoverPrimitive.Description.Props): React.JSX.Element;
+export { Popover, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

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

@@ -0,0 +1,7 @@
+import { Progress as ProgressPrimitive } from "@base-ui/react/progress";
+declare function Progress({ className, children, value, ...props }: ProgressPrimitive.Root.Props): import("react").JSX.Element;
+declare function ProgressTrack({ className, ...props }: ProgressPrimitive.Track.Props): import("react").JSX.Element;
+declare function ProgressIndicator({ className, ...props }: ProgressPrimitive.Indicator.Props): import("react").JSX.Element;
+declare function ProgressLabel({ className, ...props }: ProgressPrimitive.Label.Props): import("react").JSX.Element;
+declare function ProgressValue({ className, ...props }: ProgressPrimitive.Value.Props): import("react").JSX.Element;
+export { Progress, ProgressTrack, ProgressIndicator, ProgressLabel, ProgressValue };

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

@@ -0,0 +1,19 @@
+import * as React from "react";
+import { Questionnaire as QuestionnairePrimitive } from "@shadcn/react/questionnaire";
+import { type Button } from "./button.js";
+declare function Questionnaire({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Root>): React.JSX.Element;
+declare function QuestionnaireProgress({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Progress>): React.JSX.Element;
+declare function QuestionnaireItem({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Item>): React.JSX.Element;
+declare function QuestionnaireTitle({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Title>): React.JSX.Element;
+declare function QuestionnaireDescription({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Description>): React.JSX.Element;
+declare function QuestionnaireChoices({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Choices>): React.JSX.Element;
+declare function QuestionnaireChoice({ children, className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Choice>): React.JSX.Element;
+declare function QuestionnaireChoiceDescription({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function QuestionnaireInput({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Input>): React.JSX.Element;
+declare function QuestionnaireError({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Error>): React.JSX.Element;
+declare function QuestionnaireActions({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function QuestionnairePrevious({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Previous> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">): React.JSX.Element;
+declare function QuestionnaireSkip({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Skip> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">): React.JSX.Element;
+declare function QuestionnaireNext({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Next> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">): React.JSX.Element;
+declare function QuestionnaireSubmit({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Submit> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">): React.JSX.Element;
+export { Questionnaire, QuestionnaireActions, QuestionnaireChoice, QuestionnaireChoiceDescription, QuestionnaireChoices, QuestionnaireDescription, QuestionnaireError, QuestionnaireInput, QuestionnaireItem, QuestionnaireNext, QuestionnairePrevious, QuestionnaireProgress, QuestionnaireSkip, QuestionnaireSubmit, QuestionnaireTitle, };

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

@@ -0,0 +1,5 @@
+import { Radio as RadioPrimitive } from "@base-ui/react/radio";
+import { RadioGroup as RadioGroupPrimitive } from "@base-ui/react/radio-group";
+declare function RadioGroup({ className, ...props }: RadioGroupPrimitive.Props): import("react").JSX.Element;
+declare function RadioGroupItem({ className, ...props }: RadioPrimitive.Root.Props): import("react").JSX.Element;
+export { RadioGroup, RadioGroupItem };

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

@@ -0,0 +1,7 @@
+import * as ResizablePrimitive from "react-resizable-panels";
+declare function ResizablePanelGroup({ className, ...props }: ResizablePrimitive.GroupProps): import("react").JSX.Element;
+declare function ResizablePanel({ ...props }: ResizablePrimitive.PanelProps): import("react").JSX.Element;
+declare function ResizableHandle({ withHandle, className, ...props }: ResizablePrimitive.SeparatorProps & {
+    withHandle?: boolean;
+}): import("react").JSX.Element;
+export { ResizableHandle, ResizablePanel, ResizablePanelGroup };

package/dist/src/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import { ScrollArea as ScrollAreaPrimitive } from "@base-ui/react/scroll-area";
+declare function ScrollArea({ className, children, ...props }: ScrollAreaPrimitive.Root.Props): React.JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: ScrollAreaPrimitive.Scrollbar.Props): React.JSX.Element;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+declare function Select<Value, Multiple extends boolean | undefined = false>(props: SelectPrimitive.Root.Props<Value, Multiple>): React.JSX.Element;
+declare function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): React.JSX.Element;
+declare function SelectTrigger({ className, children, ...props }: SelectPrimitive.Trigger.Props): React.JSX.Element;
+declare function SelectContent({ className, children, align, side, sideOffset, ...props }: SelectPrimitive.Popup.Props & Pick<SelectPrimitive.Positioner.Props, "align" | "side" | "sideOffset">): React.JSX.Element;
+declare function SelectGroup(props: SelectPrimitive.Group.Props): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: SelectPrimitive.GroupLabel.Props): React.JSX.Element;
+declare function SelectItem({ className, children, ...props }: SelectPrimitive.Item.Props): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): React.JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, };

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

@@ -0,0 +1,3 @@
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+declare function Separator({ className, orientation, ...props }: SeparatorPrimitive.Props): import("react").JSX.Element;
+export { Separator };

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { Dialog as SheetPrimitive } from "@base-ui/react/dialog";
+declare function Sheet(props: SheetPrimitive.Root.Props): React.JSX.Element;
+declare function SheetTrigger({ ...props }: SheetPrimitive.Trigger.Props): React.JSX.Element;
+declare function SheetClose({ ...props }: SheetPrimitive.Close.Props): React.JSX.Element;
+declare function SheetContent({ className, children, side, showCloseButton, onKeyDown, ...props }: SheetPrimitive.Popup.Props & {
+    side?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+}): React.JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SheetFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SheetTitle({ className, ...props }: SheetPrimitive.Title.Props): React.JSX.Element;
+declare function SheetDescription({ className, ...props }: SheetPrimitive.Description.Props): React.JSX.Element;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

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

@@ -0,0 +1,63 @@
+import * as React from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./button.js";
+import { Input } from "./input.js";
+import { Separator } from "./separator.js";
+import { TooltipContent } from "./tooltip.js";
+interface SidebarContextProps {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+}
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, children, ...props }: React.ComponentProps<"div"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): React.JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, dir, ...props }: React.ComponentProps<"div"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}): React.JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+declare function SidebarRail({ className, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<"main">): React.JSX.Element;
+declare function SidebarInput({ className, ...props }: React.ComponentProps<typeof Input>): React.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): React.JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarGroupLabel({ className, render, ...props }: useRender.ComponentProps<"div"> & React.ComponentProps<"div">): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function SidebarGroupAction({ className, render, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button">): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ render, isActive, variant, size, tooltip, className, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button"> & {
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): React.JSX.Element;
+declare function SidebarMenuAction({ className, render, showOnHover, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button"> & {
+    showOnHover?: boolean;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function SidebarMenuBadge({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}): React.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+declare function SidebarMenuSubButton({ render, size, isActive, className, ...props }: useRender.ComponentProps<"a"> & React.ComponentProps<"a"> & {
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };

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

@@ -0,0 +1,7 @@
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+/**
+ * A skeleton for inline content, such as a value inside text or a button: a span, so the markup
+ * stays valid there, laid out as a block like `Skeleton`.
+ */
+declare function InlineSkeleton({ className, ...props }: React.ComponentProps<"span">): import("react").JSX.Element;
+export { InlineSkeleton, Skeleton };

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

@@ -0,0 +1,3 @@
+import { Slider as SliderPrimitive } from "@base-ui/react/slider";
+declare function Slider({ className, defaultValue, value, min, max, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, ...props }: SliderPrimitive.Root.Props): import("react").JSX.Element;
+export { Slider };

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

@@ -0,0 +1,9 @@
+import { type ToasterProps } from "sonner";
+/**
+ * Toasts are drawn here rather than by Sonner (`unstyled`), so they match the app's cards: a
+ * severity icon tinted by its type's `--toast-accent`, title and muted description, an outline
+ * action button, and a close button that shows on hover or focus (always on touch screens). Only
+ * the types set the accent; a default beside them could win by rule order.
+ */
+declare const Toaster: ({ ...props }: ToasterProps) => import("react").JSX.Element;
+export { Toaster };

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

@@ -0,0 +1,31 @@
+import { type ReactElement } from "react";
+export interface SparklinePoint {
+    at: number;
+    value: number;
+}
+interface SparklineWindowSettings {
+    sampleCount: number;
+    sampleIntervalMs: number;
+    gapThresholdMs: number;
+}
+export type SparklineWindow = SparklineWindowSettings & ({
+    kind: "fixed";
+    to: number;
+} | {
+    kind: "live";
+});
+export interface SparklineRange {
+    lower: number;
+    upper: number;
+}
+export declare function Sparkline({ points, ariaLabel, window: timeWindow, range, referenceValue, fill, strokeWidth, className, }: {
+    points: readonly SparklinePoint[];
+    ariaLabel: string;
+    window?: SparklineWindow;
+    range?: SparklineRange;
+    referenceValue?: number;
+    fill?: boolean;
+    strokeWidth?: number;
+    className?: string;
+}): ReactElement;
+export {};

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

@@ -0,0 +1,2 @@
+declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): import("react").JSX.Element;
+export { Spinner };

package/dist/src/ui/svg-diagram/dom.d.ts

@@ -0,0 +1,6 @@
+import type { SvgDiagramBinding } from "./types.js";
+export declare function sanitizeAndScopeSvg(root: SVGSVGElement, prefix: string): void;
+export declare function applySvgBindings(svg: SVGSVGElement, bindings: readonly SvgDiagramBinding[]): {
+    missing: string[];
+    cleanup: () => void;
+};

package/dist/src/ui/svg-diagram/types.d.ts

@@ -0,0 +1,13 @@
+export interface SvgDiagramBinding {
+    target: string;
+    text?: string | undefined;
+    className?: string | undefined;
+    ariaLabel?: string | undefined;
+    hidden?: boolean | undefined;
+    onActivate?: (() => void) | undefined;
+}
+export interface SvgDiagramLabels {
+    loading: string;
+    loadError: string;
+    missingTargets: (targets: readonly string[]) => string;
+}

package/dist/src/ui/svg-diagram.d.ts

@@ -0,0 +1,8 @@
+import type { SvgDiagramBinding, SvgDiagramLabels } from "./svg-diagram/types.js";
+export declare function SvgDiagram({ src, bindings, labels, ariaLabel, className, }: {
+    src: string;
+    bindings: readonly SvgDiagramBinding[];
+    labels: SvgDiagramLabels;
+    ariaLabel: string;
+    className?: string | undefined;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { Switch as SwitchPrimitive } from "@base-ui/react/switch";
+declare function Switch({ className, size, ...props }: SwitchPrimitive.Root.Props & {
+    size?: "sm" | "default";
+}): import("react").JSX.Element;
+export { Switch };

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

@@ -0,0 +1,10 @@
+import type { ComponentProps } from "react";
+declare function Table({ className, ...props }: ComponentProps<"table">): import("react").JSX.Element;
+declare function TableHeader({ className, ...props }: ComponentProps<"thead">): import("react").JSX.Element;
+declare function TableBody({ className, ...props }: ComponentProps<"tbody">): import("react").JSX.Element;
+declare function TableFooter({ className, ...props }: ComponentProps<"tfoot">): import("react").JSX.Element;
+declare function TableRow({ className, ...props }: ComponentProps<"tr">): import("react").JSX.Element;
+declare function TableHead({ className, ...props }: ComponentProps<"th">): import("react").JSX.Element;
+declare function TableCell({ className, ...props }: ComponentProps<"td">): import("react").JSX.Element;
+declare function TableCaption({ className, ...props }: ComponentProps<"caption">): import("react").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

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

@@ -0,0 +1,11 @@
+import { Tabs as TabsPrimitive } from "@base-ui/react/tabs";
+import { type VariantProps } from "class-variance-authority";
+declare function Tabs({ className, orientation, ...props }: TabsPrimitive.Root.Props): import("react").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, size, ...props }: TabsPrimitive.List.Props & VariantProps<typeof tabsListVariants>): import("react").JSX.Element;
+declare function TabsTrigger({ className, ...props }: TabsPrimitive.Tab.Props): import("react").JSX.Element;
+declare function TabsContent({ className, ...props }: TabsPrimitive.Panel.Props): import("react").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

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

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

package/dist/src/ui/theme-scope.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from "react";
+/**
+ * Keeps the overlays a subtree opens, such as dialogs, popovers and tooltips, in the light theme.
+ * Overlays render in a portal outside the subtree, so they take the scope from here; mark the
+ * subtree itself with `data-theme="light"` too.
+ */
+export declare function LightThemeScope({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The `data-theme` an overlay's popup takes, if it opens inside a theme scope. */
+export declare function useThemeScope(): "light" | undefined;

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { Toggle as TogglePrimitive } from "@base-ui/react/toggle";
+import { ToggleGroup as ToggleGroupPrimitive } from "@base-ui/react/toggle-group";
+import { type VariantProps } from "class-variance-authority";
+import { toggleVariants } from "./toggle.js";
+declare function ToggleGroup({ className, variant, size, spacing, orientation, children, ...props }: ToggleGroupPrimitive.Props & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+    orientation?: "horizontal" | "vertical";
+}): React.JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: TogglePrimitive.Props & VariantProps<typeof toggleVariants>): React.JSX.Element;
+export { ToggleGroup, ToggleGroupItem };

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

@@ -0,0 +1,8 @@
+import { Toggle as TogglePrimitive } from "@base-ui/react/toggle";
+import { type VariantProps } from "class-variance-authority";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: TogglePrimitive.Props & VariantProps<typeof toggleVariants>): import("react").JSX.Element;
+export { Toggle, toggleVariants };

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

@@ -0,0 +1,6 @@
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip";
+declare function TooltipProvider({ delay, ...props }: TooltipPrimitive.Provider.Props): import("react").JSX.Element;
+declare function Tooltip({ ...props }: TooltipPrimitive.Root.Props): import("react").JSX.Element;
+declare function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props): import("react").JSX.Element;
+declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, ...props }: TooltipPrimitive.Popup.Props & Pick<TooltipPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/src/version.d.ts

@@ -0,0 +1,2 @@
+/** This package's version, sent to the API as `workspace-ui/<version>` by local workspace hosts. */
+export declare const WORKSPACE_UI_VERSION = "0.1.0";

package/dist/src/workspace/access-label.d.ts

@@ -0,0 +1,2 @@
+import type { WorkspaceAccess } from "@overvis/hmi-shared/workspace";
+export declare function workspaceAccessLabel(access: WorkspaceAccess): string;

package/dist/src/workspace/alarms/actions.d.ts

@@ -0,0 +1,19 @@
+import { type Alarm } from "@overvis/hmi-shared/automation";
+/** The shelf lengths an operator picks from. */
+export declare const ALARM_SHELVE_DURATIONS: readonly [number, number, number, number, number];
+export declare function AcknowledgeAlarmDialog({ alarm, title, onClose, }: {
+    alarm: Alarm;
+    /** The alarm's title as the list shows it. */
+    title: string;
+    onClose: () => void;
+}): import("react").JSX.Element;
+export declare function ShelveAlarmDialog({ alarm, title, onClose, }: {
+    alarm: Alarm;
+    title: string;
+    onClose: () => void;
+}): import("react").JSX.Element;
+export declare function UnshelveAlarmDialog({ alarm, title, onClose, }: {
+    alarm: Alarm;
+    title: string;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/alarms/alarm-list.d.ts

@@ -0,0 +1,65 @@
+import { type ReactNode } from "react";
+import { type Alarm, type AlarmSource } from "@overvis/hmi-shared/automation";
+import { type AlarmFilter } from "./model.js";
+type Severity = Alarm["severity"];
+/** The title and body an alarm shows: its message, or what an input-unavailable alarm means. */
+export declare function alarmDisplayText(alarm: {
+    source: AlarmSource;
+    key: string;
+}, message: {
+    title: string;
+    body: string;
+}): {
+    title: string;
+    body: string;
+};
+export declare function AlarmSeverityBadge({ severity }: {
+    severity: Severity;
+}): import("react").JSX.Element;
+/** Names of the workspace's alarm rules and automations, for showing where an alarm comes from. */
+export declare function useAlarmSourceNames(workspaceId: string, enabled: boolean): {
+    names: Map<string, string>;
+    rules: {
+        id: string;
+        workspaceId: string;
+        revision: number;
+        name: string | Record<string, string>;
+        description: string | Record<string, string> | null;
+        dashboardId: string | null;
+        disabledSince: string | null;
+        errorCount: number;
+        warningCount: number;
+        createdAt: string;
+        updatedAt: string;
+        severity: "info" | "urgent" | "warning";
+    }[];
+    automations: {
+        readonly id: string;
+        readonly workspaceId: string;
+        readonly revision: number;
+        readonly name: string | Record<string, string>;
+        readonly description: string | Record<string, string> | null;
+        readonly dashboardId: string | null;
+        readonly disabledSince: string | null;
+        readonly errorCount: number;
+        readonly warningCount: number;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    }[];
+    name: (source: AlarmSource) => string | null;
+};
+export interface AlarmListProps extends AlarmFilter {
+    /** Defaults to the open workspace. */
+    readonly workspaceId?: string;
+    /** Hides message bodies and source names, for a dashboard panel. */
+    readonly compact?: boolean;
+    /** Shown when no alarm matches; a default line otherwise. */
+    readonly empty?: ReactNode;
+    readonly className?: string;
+}
+/**
+ * The live active alarms of a workspace, those waiting for acknowledgement first, filtered by
+ * source, key prefix or parameters. Operators and above acknowledge and shelve from it.
+ */
+export declare function AlarmList({ workspaceId: workspaceIdProp, sourceIds, keyPrefix, parameterIds, compact, empty, className, }: AlarmListProps): import("react").JSX.Element;
+export {};