@labpane/ui 0.0.0-stage → 1.2.0

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

@@ -0,0 +1,28 @@
+import * as React from "react";
+declare const InputGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const addonAlignments: {
+    "inline-start": string;
+    "inline-end": string;
+    "block-start": string;
+    "block-end": string;
+};
+declare const InputGroupAddon: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    align?: keyof typeof addonAlignments;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const groupButtonSizes: {
+    xs: string;
+    sm: string;
+    "icon-xs": string;
+    "icon-sm": string;
+};
+declare const InputGroupButton: React.ForwardRefExoticComponent<Omit<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    variant?: import("./button.js").ButtonVariant | null;
+    size?: import("./button.js").ButtonSize | null;
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>, "ref">, "size"> & {
+    size?: keyof typeof groupButtonSizes;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const InputGroupText: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const InputGroupInput: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const InputGroupTextarea: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

package/dist/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/ui/kbd.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+declare const Kbd: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const KbdGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export { Kbd, KbdGroup };

package/dist/ui/label.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Label: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/ui/menu.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+export type MenuAction = {
+    label: string;
+    onSelect: () => void;
+    disabled?: boolean;
+    checked?: boolean;
+} | {
+    label: string;
+    items: MenuAction[];
+} | null;
+export type MenuOption = {
+    id: string;
+    label: string;
+    group?: string;
+    icon?: React.ReactNode;
+};
+declare function DropdownMenu({ open, defaultOpen, onOpenChange, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): React.JSX.Element;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const itemVariants: {
+    default: string;
+    destructive: string;
+};
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    variant?: keyof typeof itemVariants;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export declare function MenuContent({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+export declare function ActionMenu({ children, actions, onCloseAutoFocus, }: {
+    children: React.ReactElement;
+    actions: MenuAction[];
+    onCloseAutoFocus?: (event: Event) => void;
+}): React.JSX.Element;
+export declare function OptionMenu({ trigger, options, onSelect, open, onOpenChange, onCloseAutoFocus, }: {
+    trigger: React.ReactElement;
+    options: readonly MenuOption[];
+    onSelect: (id: string) => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onCloseAutoFocus?: (event: Event) => void;
+}): React.JSX.Element;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const NativeSelect: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>, "ref">, "size"> & {
+    size?: "sm" | "default";
+} & React.RefAttributes<HTMLSelectElement>>;
+declare const NativeSelectOption: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>, "ref"> & React.RefAttributes<HTMLOptionElement>>;
+declare const NativeSelectOptGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>, "ref"> & React.RefAttributes<HTMLOptGroupElement>>;
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };

package/dist/ui/nav-tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const NavTabs: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const NavTab: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    active?: boolean;
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+export { NavTabs, NavTab };

package/dist/ui/overlay.d.ts

@@ -0,0 +1 @@
+export declare function useOverlayOpen(open: boolean | undefined, onOpenChange: ((open: boolean) => void) | undefined, defaultOpen?: boolean): [boolean, (open: boolean) => void];

package/dist/ui/page.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+declare const PageActions: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const PageHeaderText: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const PageEyebrow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const PageTitle: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const PageDescription: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const PageHeader: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "title"> & {
+    title?: React.ReactNode;
+    eyebrow?: React.ReactNode;
+    description?: React.ReactNode;
+    leading?: React.ReactNode;
+    actions?: React.ReactNode;
+    variant?: "bar";
+} & React.RefAttributes<HTMLElement>>;
+declare const Page: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title"> & {
+    title?: React.ReactNode;
+    actions?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Back: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    label: string;
+} & React.RefAttributes<HTMLAnchorElement>>;
+export { Back, Page, PageActions, PageDescription, PageEyebrow, PageHeader, PageHeaderText, PageTitle, };

package/dist/ui/rail.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+declare const Rail: React.ForwardRefExoticComponent<Omit<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+} & React.RefAttributes<HTMLDivElement>, "ref">, "collapsible"> & React.RefAttributes<HTMLDivElement>>;
+declare const RailItem: React.ForwardRefExoticComponent<Omit<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    variant?: "default" | "outline";
+    size?: "default" | "lg" | "sm";
+    tooltip?: string | React.ComponentProps<React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-tooltip").TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>>;
+} & React.RefAttributes<HTMLButtonElement>, "ref">, "isActive"> & {
+    active?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Rail, RailItem };

package/dist/ui/search-input.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const SearchInput: React.ForwardRefExoticComponent<Omit<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & {
+    onClear?: () => void;
+    clearLabel?: string;
+} & React.RefAttributes<HTMLInputElement>>;
+export { SearchInput };

package/dist/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ value, defaultValue, onValueChange, ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare function SelectValue(props: React.ComponentProps<typeof SelectPrimitive.Value>): React.JSX.Element;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    size?: "sm" | "default";
+    variant?: "default" | "ghost";
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    hint?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue };

package/dist/ui/separator.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const Separator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/ui/settings.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+declare const SettingsSection: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "title"> & {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const SettingsRow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    htmlFor?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SettingsFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    status?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export { SettingsSection, SettingsRow, SettingsFooter };

package/dist/ui/sheet.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+declare function Sheet({ open, defaultOpen, onOpenChange, ...props }: React.ComponentProps<typeof SheetPrimitive.Root>): React.JSX.Element;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const sheetSides: {
+    right: string;
+    left: string;
+    top: string;
+    bottom: string;
+};
+declare const SheetContent: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    side?: keyof typeof sheetSides;
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SheetFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/ui/side-panel.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+export type SidePanelLimits = {
+    minWidth: number;
+    maxWidth: number;
+    slack: number;
+    mainMinWidth: number;
+};
+export declare const sidePanelLimits: SidePanelLimits;
+export declare function resolveDrag(desired: number, available: number, limits: SidePanelLimits): {
+    open: boolean;
+    width: number;
+};
+declare const SidePanel: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "children"> & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    width: number;
+    onWidthChange: (width: number) => void;
+    side?: "left" | "right";
+    label: string;
+    limits?: Partial<SidePanelLimits>;
+    children: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+export { SidePanel };

package/dist/ui/sidebar.d.ts

@@ -0,0 +1,81 @@
+import * as React from "react";
+import { TooltipContent } from "./tooltip.js";
+type SidebarState = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarState;
+declare const SidebarProvider: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    shortcut?: string | null;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    variant?: import("./button.js").ButtonVariant | null;
+    size?: import("./button.js").ButtonSize | null;
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarRail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarInset: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const SidebarInput: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const SidebarHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSeparator: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupLabel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupAction: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const menuButtonVariants: {
+    default: string;
+    outline: string;
+};
+declare const menuButtonSizes: {
+    default: string;
+    sm: string;
+    lg: string;
+};
+declare const SidebarMenuButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    variant?: keyof typeof menuButtonVariants;
+    size?: keyof typeof menuButtonSizes;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuAction: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuBadge: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSkeleton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    showIcon?: boolean;
+    width?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSub: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuSubItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuSubButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+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/ui/skeleton.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Skeleton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Skeleton };

package/dist/ui/spinner.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Spinner: React.ForwardRefExoticComponent<Omit<React.SVGProps<SVGSVGElement>, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export { Spinner };

package/dist/ui/stat.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const Stats: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDListElement>, HTMLDListElement>, "ref"> & React.RefAttributes<HTMLDListElement>>;
+declare const Stat: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const StatLabel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const StatValue: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const StatDetail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export { Stats, Stat, StatLabel, StatValue, StatDetail };

package/dist/ui/steps.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const Steps: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const Step: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    active?: boolean;
+    index: number;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Steps, Step };

package/dist/ui/switch.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    size?: "default" | "sm";
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/ui/tab-state.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export type TabState = {
+    active: boolean;
+    visible: boolean;
+};
+export declare const TabStateContext: React.Context<TabState>;
+export declare function useTabActive(): boolean;
+export declare function useTabVisible(): boolean;

package/dist/ui/table-layout.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+export declare function useTableWindow(count: number, rowHeight?: number): {
+    scrollRef: React.RefObject<HTMLDivElement | null>;
+    range: {
+        start: number;
+        end: number;
+    };
+    reveal: (index: number) => void;
+    viewportHeight: number;
+};
+export declare function useColumnResize(): {
+    widths: Record<string, number>;
+    change: (id: string, width: number) => void;
+    start: (event: React.PointerEvent<HTMLElement>, id: string, initial: number) => void;
+};
+export declare function useLoadMore(root: React.RefObject<HTMLElement | null>, onLoadMore: (() => void | Promise<void>) | undefined, hasMore: boolean): {
+    sentinel: React.RefObject<HTMLTableRowElement | null>;
+    loading: boolean;
+};

package/dist/ui/table-model.d.ts

@@ -0,0 +1,42 @@
+import type * as React from "react";
+export type SortDirection = "asc" | "desc";
+export type TableSort = {
+    column: string;
+    direction: SortDirection;
+};
+export type SortValue = string | number | boolean | null | undefined;
+export type TableColumn<T> = {
+    id: string;
+    header: React.ReactNode;
+    headerDetail?: React.ReactNode;
+    srOnly?: boolean;
+    rowHeader?: boolean;
+    className?: string | ((row: T, index: number) => string | undefined);
+    headClassName?: string;
+    cell: (row: T, index: number) => React.ReactNode;
+    sortValue?: (row: T) => SortValue;
+    sort?: boolean;
+    align?: "start" | "end" | "center";
+    numeric?: boolean;
+    width?: string;
+    hideBelow?: "sm" | "md" | "lg";
+};
+export declare function compareValues(left: SortValue, right: SortValue): number;
+export declare function sortRows<T>(rows: readonly T[], columns: TableColumn<T>[], sort: TableSort | null): readonly T[];
+export declare const isSortable: <T>(column: TableColumn<T>) => boolean;
+export declare function nextSort<T>(column: TableColumn<T>, current: TableSort | null): TableSort;
+export declare function pageOf<T>(rows: readonly T[], pageSize: number | undefined, page: number): {
+    size: number;
+    pages: number;
+    current: number;
+    offset: number;
+    rows: readonly T[];
+};
+export declare function visibleRowRange(count: number, scrollTop: number, height: number, rowHeight: number, overscan?: number): {
+    start: number;
+    end: number;
+};
+export declare const clampColumnWidth: (width: number) => number;
+export declare function column<T>(id: string, header: string, value: (row: T) => SortValue, cell?: (row: T) => React.ReactNode): TableColumn<T>;
+export declare const mono: <T>(id: string, header: string, value: (row: T) => unknown) => TableColumn<T>;
+export declare const num: <T>(id: string, header: string, value: (row: T) => number, digits?: number, headerDetail?: string) => TableColumn<T>;

package/dist/ui/table-screen.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const TableScreen: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title"> & {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    tabs?: React.ReactNode;
+    error?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export { TableScreen };

package/dist/ui/table.d.ts

@@ -0,0 +1,41 @@
+import * as React from "react";
+import { type TableColumn, type TableSort } from "./table-model.js";
+export type { SortDirection, SortValue, TableColumn, TableSort, } from "./table-model.js";
+export { column, mono, num } from "./table-model.js";
+export type TableProps<T> = {
+    label?: string;
+    caption?: string;
+    columns: TableColumn<T>[];
+    rows: readonly T[];
+    rowKey: (row: T, index: number) => string;
+    empty?: React.ReactNode;
+    className?: string;
+    tableClassName?: string;
+    scrollClassName?: string;
+    rowClassName?: (row: T) => string | undefined;
+    loading?: boolean;
+    skeletonRows?: number;
+    sort?: TableSort | null;
+    defaultSort?: TableSort | null;
+    onSortChange?: (sort: TableSort | null) => void;
+    clientSort?: boolean;
+    sortDisabled?: boolean;
+    onRowActivate?: (row: T) => void;
+    rowLabel?: (row: T) => string;
+    selectedKey?: string | null;
+    pageSize?: number;
+    rowHeight?: number;
+    onLoadMore?: () => void | Promise<void>;
+    hasMore?: boolean;
+    banner?: React.ReactNode;
+    tabs?: React.ReactNode;
+    footerStart?: React.ReactNode;
+    footerCenter?: React.ReactNode;
+    footerEnd?: React.ReactNode;
+};
+declare function Table<T>({ label, caption, columns, rows, rowKey, empty, className, tableClassName, scrollClassName, rowClassName, loading, skeletonRows, sort, defaultSort, onSortChange, clientSort, sortDisabled, onRowActivate, rowLabel, selectedKey, pageSize, rowHeight, onLoadMore, hasMore, banner, tabs, footerStart, footerCenter, footerEnd, }: TableProps<T>): React.JSX.Element;
+declare function TableStack({ title, detail, }: {
+    title: React.ReactNode;
+    detail?: React.ReactNode;
+}): React.JSX.Element;
+export { Table, TableStack };

package/dist/ui/tabs.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const Tabs: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const tabsListVariants: {
+    default: string;
+    line: string;
+};
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: keyof typeof tabsListVariants;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/ui/terminal.d.ts

@@ -0,0 +1,57 @@
+import { type TerminalCore } from "@wterm/dom";
+export type TerminalTheme = {
+    foreground: number;
+    background: number;
+    cursor: number;
+    palette: number[];
+};
+export type TerminalShell = {
+    attach: (write: (data: string) => void) => unknown;
+    handleInput: (data: string) => unknown;
+};
+export type TerminalHandle = {
+    reconnect: () => void;
+    focus: () => void;
+};
+export declare const terminalThemes: {
+    dark: {
+        foreground: number;
+        background: number;
+        cursor: number;
+        palette: number[];
+    };
+    light: {
+        foreground: number;
+        background: number;
+        cursor: number;
+        palette: number[];
+    };
+    solarized: {
+        foreground: number;
+        background: number;
+        cursor: number;
+        palette: number[];
+    };
+    monokai: {
+        foreground: number;
+        background: number;
+        cursor: number;
+        palette: number[];
+    };
+};
+export type TerminalThemeName = "auto" | keyof typeof terminalThemes;
+export type TerminalProps = ({
+    connect: () => string | URL | Promise<string | URL>;
+    shell?: undefined;
+} | {
+    shell: () => TerminalShell | Promise<TerminalShell>;
+    connect?: undefined;
+}) & {
+    core?: () => Promise<TerminalCore & {
+        dispose?: () => void;
+    }>;
+    theme?: TerminalThemeName | TerminalTheme;
+    expandable?: boolean;
+    className?: string;
+};
+export declare const Terminal: import("react").ForwardRefExoticComponent<TerminalProps & import("react").RefAttributes<TerminalHandle>>;

package/dist/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/ui/theme.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+export declare const themeColors: readonly ["background", "foreground", "card", "card-foreground", "popover", "popover-foreground", "primary", "primary-foreground", "link", "secondary", "secondary-foreground", "muted", "muted-foreground", "accent", "accent-foreground", "destructive", "destructive-foreground", "destructive-muted", "success", "success-foreground", "warning", "warning-foreground", "info", "info-foreground", "border", "input", "input-background", "ring", "overlay", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5", "sidebar", "sidebar-foreground", "sidebar-primary", "sidebar-primary-foreground", "sidebar-accent", "sidebar-accent-foreground", "sidebar-border", "sidebar-ring"];
+export type ThemeColor = (typeof themeColors)[number];
+export type ThemeColors = Partial<Record<ThemeColor, string>>;
+export type Theme = {
+    light?: ThemeColors;
+    dark?: ThemeColors;
+    fonts?: {
+        sans?: string;
+        mono?: string;
+        display?: string;
+    };
+    radius?: string;
+    radiusDialog?: string;
+};
+export declare function themeCss(theme: Theme, selector?: string): string;
+export declare function ThemeStyle({ theme, selector, }: {
+    theme: Theme;
+    selector?: string;
+}): React.ReactElement<{
+    "data-slot": string;
+}, string | React.JSXElementConstructor<any>>;