@termix-ssh/plugin-sdk 1.0.0

package/dist/host/types/src/ui/components/password-input.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+type PasswordInputProps = React.InputHTMLAttributes<HTMLInputElement>;
+export declare const PasswordInput: React.ForwardRefExoticComponent<PasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+export {};

package/dist/host/types/src/ui/components/popover.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): React.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): React.JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): React.JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/dist/host/types/src/ui/components/scroll-area.d.ts

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

package/dist/host/types/src/ui/components/section-card.d.ts

@@ -0,0 +1,29 @@
+import type React from "react";
+export declare function SectionCard({ title, icon, action, children, className, rowId, }: {
+    title: string;
+    icon: React.ReactNode;
+    action?: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+    /** Lets settings search jump to this card. */
+    rowId?: string;
+}): React.JSX.Element;
+export declare function SettingRow({ label, badge, description, defaultKey, rowId, children, }: {
+    label: string;
+    badge?: string;
+    description?: React.ReactNode;
+    /**
+     * In the host editor, the host default this row edits: a plugin's own
+     * field key, or "core.<key>". Shows where the value comes from.
+     */
+    defaultKey?: string;
+    /** Lets settings search jump to this row. */
+    rowId?: string;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function FakeSwitch({ defaultChecked, disabled, checked, onChange, }: {
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    checked?: boolean;
+    onChange?: (v: boolean) => void;
+}): React.JSX.Element;

package/dist/host/types/src/ui/components/select.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): React.JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): React.JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+}): React.JSX.Element;
+declare function SelectContent({ className, children, position, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): React.JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): React.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): React.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): React.JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/host/types/src/ui/components/select2.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+type Select2Props = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "value" | "defaultValue" | "onChange"> & Pick<React.SelectHTMLAttributes<HTMLSelectElement>, "value" | "defaultValue" | "onChange" | "required"> & {
+    placeholder?: string;
+    align?: "start" | "center" | "end";
+    contentClassName?: string;
+};
+declare function Select2({ className, children, value, defaultValue, onChange, disabled, placeholder, align, contentClassName, name, id, required, "aria-label": ariaLabel, ...props }: Select2Props): React.JSX.Element;
+export { Select2 };

package/dist/host/types/src/ui/components/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Separator as SeparatorPrimitive } from "radix-ui";
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): React.JSX.Element;
+export { Separator };

package/dist/host/types/src/ui/components/sheet.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { Dialog as SheetPrimitive } from "radix-ui";
+declare function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive.Root>): React.JSX.Element;
+declare function SheetTrigger({ ...props }: React.ComponentProps<typeof SheetPrimitive.Trigger>): React.JSX.Element;
+declare function SheetClose({ ...props }: React.ComponentProps<typeof SheetPrimitive.Close>): React.JSX.Element;
+declare function SheetContent({ className, children, side, showCloseButton, ...props }: React.ComponentProps<typeof SheetPrimitive.Content> & {
+    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 }: React.ComponentProps<typeof SheetPrimitive.Title>): React.JSX.Element;
+declare function SheetDescription({ className, ...props }: React.ComponentProps<typeof SheetPrimitive.Description>): React.JSX.Element;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/host/types/src/ui/components/sidebar.d.ts

@@ -0,0 +1,69 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./button";
+import { Input } from "./input";
+import { Separator } from "./separator";
+import { TooltipContent } from "./tooltip";
+type 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, style, 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, asChild, ...props }: React.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+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";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): React.JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): React.JSX.Element;
+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({ asChild, size, isActive, className, ...props }: React.ComponentProps<"a"> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): React.JSX.Element;
+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/host/types/src/ui/components/skeleton.d.ts

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

package/dist/host/types/src/ui/components/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): React.JSX.Element;
+export { Slider };

package/dist/host/types/src/ui/components/sonner.d.ts

@@ -0,0 +1,4 @@
+import { Toaster as Sonner } from "sonner";
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+declare const Toaster: ({ ...props }: ToasterProps) => import("react").JSX.Element;
+export { Toaster };

package/dist/host/types/src/ui/components/surface/prompt-styles.d.ts

@@ -0,0 +1,4 @@
+/** Buttons shared by every PanePrompt, so confirms and prompts match. */
+export declare const PROMPT_BUTTON = "inline-flex h-7 items-center justify-center gap-1.5 border border-border px-3 text-xs text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50";
+export declare const PROMPT_PRIMARY_BUTTON = "inline-flex h-7 items-center justify-center gap-1.5 border border-accent-brand/40 px-3 text-xs font-medium text-accent-brand transition-colors hover:bg-accent-brand/10 focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50";
+export declare const PROMPT_DESTRUCTIVE_BUTTON = "inline-flex h-7 items-center justify-center gap-1.5 bg-destructive px-3 text-xs font-medium text-white transition-colors hover:bg-destructive/90 focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50";

package/dist/host/types/src/ui/components/surface/surface-scope.d.ts

@@ -0,0 +1,79 @@
+import type React from "react";
+/**
+ * A surface is a sidebar panel, a tab or a split pane. Inline views and
+ * confirmations draw over the surface that asked, never over the whole app.
+ */
+export type EditingWidth = boolean | "wide";
+export type SurfaceKind = "panel" | "tab" | "pane";
+export interface ConfirmOptions {
+    title: string;
+    description?: React.ReactNode;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    /** Red confirm button. Defaults to true, since most confirms delete. */
+    destructive?: boolean;
+}
+export declare function SurfaceScope({ kind, onEditingChange, className, children, }: {
+    kind?: SurfaceKind;
+    /** Gets the widest open inline view, so a sidebar can widen for it. */
+    onEditingChange?: (editing: EditingWidth) => void;
+    className?: string;
+    children: React.ReactNode;
+}): React.JSX.Element;
+/** Which kind of surface this code renders in, or null outside any. */
+export declare function useSurfaceKind(): SurfaceKind | null;
+/**
+ * Asks a yes or no question over the surface that called it. Enter confirms
+ * and Esc cancels, before a terminal can see the key.
+ */
+export declare function useConfirm(): (options: ConfirmOptions) => Promise<boolean>;
+/**
+ * A small card over the surface it sits in. Confirmations use it, and so do
+ * prompts that belong to a connection, like a sudo password.
+ */
+export declare function PanePrompt({ open, title, titleId, description, icon, tone, actions, onCancel, role, labelledBy, layer, backgroundColor, className, children, }: {
+    open: boolean;
+    title: React.ReactNode;
+    titleId?: string;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    tone?: "default" | "destructive";
+    actions?: React.ReactNode;
+    /** Clicking the dimmed backdrop. */
+    onCancel?: () => void;
+    role?: "dialog" | "alertdialog";
+    labelledBy?: string;
+    /**
+     * "connection" covers a connecting surface (a terminal waiting on a login)
+     * with an opaque backdrop, above everything the surface draws.
+     */
+    layer?: "pane" | "connection";
+    /** Backdrop color for the connection layer, usually the terminal theme. */
+    backgroundColor?: string;
+    className?: string;
+    children?: React.ReactNode;
+}): React.JSX.Element;
+/**
+ * What used to be a modal: a view that takes over the surface it was opened
+ * from, with a Back button. Opened from a sidebar it widens the sidebar.
+ */
+export declare function InlineView({ open, onOpenChange, title, icon, status, actions, toolbar, footer, width, onBeforeClose, scroll, bare, className, children, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: React.ReactNode;
+    icon?: React.ReactNode;
+    status?: React.ReactNode;
+    actions?: React.ReactNode;
+    toolbar?: React.ReactNode;
+    /** Pinned under the body, usually Cancel and Save. */
+    footer?: React.ReactNode;
+    /** How far a sidebar widens while this is open. */
+    width?: EditingWidth;
+    /** Return false to stay open, for an unsaved changes guard. */
+    onBeforeClose?: () => boolean | Promise<boolean>;
+    scroll?: boolean;
+    /** Draw children edge to edge, for views with their own bands. */
+    bare?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}): React.ReactPortal;

package/dist/host/types/src/ui/components/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+declare function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>): React.JSX.Element;
+export { Switch };

package/dist/host/types/src/ui/components/tab-strip.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from "react";
+export interface TabStripItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    /** Small count after the label. */
+    count?: number;
+}
+/** Scrollable underline tabs with overflow arrows. */
+export declare function TabStrip({ tabs, activeTab, onTabChange, isActive, variant, trailing, className, }: {
+    tabs: TabStripItem[];
+    activeTab: string;
+    onTabChange: (id: string) => void;
+    isActive?: (id: string) => boolean;
+    variant?: "primary" | "secondary";
+    /** Sits after the tabs, outside the scroll area. */
+    trailing?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/components/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare function Tabs({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): React.JSX.Element;
+declare function TabsList({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.List>): React.JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): React.JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): React.JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/host/types/src/ui/components/textarea.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+export type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/host/types/src/ui/components/theme-provider.d.ts

@@ -0,0 +1,14 @@
+import type { ThemeId } from "../../types/ui-types";
+type ThemeProviderProps = {
+    children: React.ReactNode;
+    defaultTheme?: ThemeId;
+    storageKey?: string;
+};
+type ThemeProviderState = {
+    theme: ThemeId;
+    setTheme: (theme: ThemeId) => void;
+    setThemePreview: (theme: ThemeId | null) => void;
+};
+export declare function ThemeProvider({ children, defaultTheme, storageKey, ...props }: ThemeProviderProps): import("react").JSX.Element;
+export declare const useTheme: () => ThemeProviderState;
+export {};

package/dist/host/types/src/ui/components/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): React.JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): React.JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): React.JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): React.JSX.Element;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/host/types/src/ui/contexts/BrandingContext.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+import { type BrandingSettings } from "../api/settings-api";
+interface BrandingContextValue {
+    ready: boolean;
+    appName: string;
+    tagline: string;
+    logo: string | null;
+    /** Re-applies a freshly saved BrandingSettings without a page reload. */
+    applyBranding: (settings: BrandingSettings) => void;
+}
+export declare function BrandingProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useBranding(): BrandingContextValue;
+export {};

package/dist/host/types/src/ui/contexts/UiPreferencesContext.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from "react";
+import { type UiPluginPresets, type UiAreaKey, type UiAreaPreferences, type UiPreferences, type UiPreset } from "../../types/ui-preferences";
+interface UiPreferencesContextValue {
+    preferences: UiPreferences;
+    loaded: boolean;
+    resolve: <A extends UiAreaKey>(area: A) => UiAreaPreferences[A];
+    setPreset: (preset: UiPreset) => void;
+    setOverride: <A extends UiAreaKey, K extends keyof UiAreaPreferences[A]>(area: A, key: K, value: UiAreaPreferences[A][K] | null) => void;
+    clearArea: (area: UiAreaKey) => void;
+    clearAllOverrides: () => void;
+    completeOnboarding: (skipped: boolean) => void;
+    /** A plugin's own area, from the presets it declared. */
+    resolvePlugin: (pluginId: string, presets: UiPluginPresets | undefined) => Record<string, unknown>;
+    setPluginOverride: (pluginId: string, key: string, value: unknown) => void;
+}
+/**
+ * App-wide interface preset and per-area overrides. Cached in localStorage for
+ * instant paint and synced to the backend when storageMode is "cloud", the
+ * same shape as useHostSidebarPreferences -- but provided once at the app root
+ * rather than mounted per consumer, since almost every panel reads it.
+ *
+ * Writes send only the changed slice: the backend merges overrides two levels
+ * deep and treats null as "clear this", so handing a knob back to the preset is
+ * a single PUT rather than a read-modify-write of the whole document.
+ */
+export declare function UiPreferencesProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useUiPreferencesContext(): UiPreferencesContextValue | null;
+/**
+ * Effective settings for one area. Falls back to the balanced preset (today's
+ * behavior) outside a provider, so components rendered in isolation -- tests,
+ * Electron sub-windows -- behave exactly as they did before presets existed
+ * rather than crashing or silently going Simple.
+ */
+export declare function useAreaPreferences<A extends UiAreaKey>(area: A): UiAreaPreferences[A];
+export declare function useUiPreference<A extends UiAreaKey, K extends keyof UiAreaPreferences[A]>(area: A, key: K): UiAreaPreferences[A][K];
+export {};

package/dist/host/types/src/ui/contexts/branding-document.d.ts

@@ -0,0 +1,10 @@
+export declare const BRANDING_ICON_SELECTORS: readonly ["link[rel=\"icon\"]", "link[rel=\"apple-touch-icon\"]"];
+/**
+ * Snapshot bundled favicon hrefs before the first custom logo is written.
+ * Reset then restores those snapshots instead of leaving the previous upload
+ * in the tab until a full reload.
+ */
+export declare function captureDefaultIconHrefs(stored: Record<string, string>, query: (selector: string) => {
+    href: string;
+} | null): void;
+export declare function nextIconHref(customLogo: string | null, defaultHref: string | undefined, currentHref: string): string;

package/dist/host/types/src/ui/dashboard/dashboard-cards-registry.d.ts

@@ -0,0 +1,30 @@
+import type { ComponentType } from "react";
+import type { TabShellCallbacks } from "../shell/tab-registry";
+export interface DashboardCardRenderProps {
+    isVisible: boolean;
+    /** The shell, e.g. to open the full-page version of the card. */
+    shell: TabShellCallbacks;
+}
+/**
+ * A dashboard card a plugin contributes. DashboardTab offers registered cards
+ * next to the core ones, and a saved slot whose card is not registered keeps
+ * its place and shows a placeholder, so turning a plugin off and on again
+ * puts the card back where it was.
+ */
+export interface RegisteredDashboardCard {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    defaultHeight?: number;
+    /** Which column a preset places this card in by default. Defaults to "main". */
+    defaultPanel?: "main" | "side";
+    /** "framed" gets a titled header from the dashboard; "bare" draws its own. */
+    frame?: "framed" | "bare";
+    component: ComponentType<DashboardCardRenderProps>;
+}
+export declare const registerDashboardCard: (item: RegisteredDashboardCard) => () => void;
+export declare const unregisterDashboardCard: (id: string) => void;
+export declare const getRegisteredDashboardCard: (id: string) => RegisteredDashboardCard;
+export declare const registeredDashboardCardList: () => RegisteredDashboardCard[];
+export declare const useRegisteredDashboardCards: () => RegisteredDashboardCard[];
+export declare const resetDashboardCards: () => void;

package/dist/host/types/src/ui/hooks/use-action-slot.d.ts

@@ -0,0 +1,10 @@
+import { type SlotContribution } from "../shell/action-registry";
+/**
+ * The contributions in a slot that the current user may actually see.
+ *
+ * A slot owner calls this without knowing which plugins contributed, or
+ * whether any did. Contributions the user lacks the permission for are
+ * dropped entirely rather than disabled, which is how admin-gated UI already
+ * behaves elsewhere in the app.
+ */
+export declare function useActionSlot(slotId: string, context?: Record<string, unknown>): SlotContribution[];

package/dist/host/types/src/ui/hooks/use-adaptive-polling.d.ts

@@ -0,0 +1,5 @@
+import { type AdaptivePollResult, type AdaptivePollingPolicy } from "../lib/adaptive-polling";
+export declare function useAdaptivePolling(poll: () => AdaptivePollResult | Promise<AdaptivePollResult>, policy: AdaptivePollingPolicy, enabled?: boolean, options?: {
+    runImmediately?: boolean;
+    onError?: (error: unknown) => void;
+}): void;

package/dist/host/types/src/ui/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/host/types/src/ui/hooks/use-permissions.d.ts

@@ -0,0 +1,29 @@
+export interface PermissionsState {
+    permissions: string[];
+    isAdmin: boolean;
+    /** False until the call answers, so gated UI does not flash in or out. */
+    loaded: boolean;
+    has: (permission: string) => boolean;
+}
+/** The same answer usePermissions().has gives, for code outside a component. */
+export declare function hasPermission(permission: string): Promise<boolean>;
+/**
+ * Warms the permissions cache before the shell mounts, so permission-gated
+ * rail items are already known on first paint instead of popping in once
+ * usePermissions' own fetch resolves.
+ */
+export declare function preloadPermissions(): Promise<void>;
+export declare function notifyPermissionsChanged(): void;
+/**
+ * The current user's grants.
+ *
+ * Freshness is eventually consistent: the backend caches per user with a TTL
+ * and this caches until notifyPermissionsChanged fires, so a revoke can leave
+ * a stale button on screen briefly. That is acceptable because the button is
+ * not the boundary - clicking it hits a route that checks again and refuses.
+ */
+export declare function usePermissions(): PermissionsState;
+/** Test seam. */
+export declare function resetPermissionsCache(): void;
+/** Test seam: answers every hook with these grants, no request made. */
+export declare function setPermissionsForTesting(permissions: string[], isAdmin?: boolean): void;

package/dist/host/types/src/ui/hooks/use-status-color-scheme.d.ts

@@ -0,0 +1,12 @@
+import type { StatusColorScheme } from "../../types/host-sidebar-preferences";
+export type { StatusColorScheme };
+/**
+ * Reads the scheme straight off the sidebar preferences cache that
+ * useHostSidebarPreferences writes, so the toggle in Customize Sidebar takes
+ * effect without a reload. Exported for imperative callers that build markup
+ * outside React (the topology SVG).
+ */
+export declare function readStatusColorScheme(): StatusColorScheme;
+export declare function useStatusColorScheme(): StatusColorScheme;
+/** Returns Tailwind class names for a status dot/stripe. */
+export declare function getStatusClasses(status: boolean | "online" | "offline" | "unknown", scheme: StatusColorScheme, variant: "dot" | "stripe" | "badge", loading?: boolean): string;

package/dist/host/types/src/ui/hooks/use-sync-status.d.ts

@@ -0,0 +1,4 @@
+/** The desktop's sync status, kept current while the component is mounted. */
+export declare function useSyncStatus(): any;
+/** What needs the user's attention in Sync, for the rail badge. */
+export declare function useSyncAttentionCount(): number | null;

package/dist/host/types/src/ui/hooks/useSshAuthProviders.d.ts

@@ -0,0 +1,17 @@
+import { type SshAuthProviderSummary } from "../api/auth-methods-api";
+/** Drops the cached list, e.g. after a plugin was switched on or off. */
+export declare function invalidateSshAuthProviders(): void;
+export interface SshAuthTypeOption extends SshAuthProviderSummary {
+    /** Plugin-registered editor title, when there is one. */
+    editorTitleKey?: string;
+}
+/**
+ * Every SSH auth type the server can connect with, merged with the editors
+ * plugins registered in this browser. Types whose plugin is off come back
+ * with available: false and missingPlugin set.
+ */
+export declare function useSshAuthProviders(): {
+    providers: SshAuthTypeOption[];
+    loaded: boolean;
+    find: (type: string | null | undefined) => SshAuthTypeOption | undefined;
+};

package/dist/host/types/src/ui/i18n/i18n.d.ts

@@ -0,0 +1,52 @@
+import i18n, { type ResourceKey } from "i18next";
+/** i18n code -> translated file name, shared by core and plugin locales. */
+export declare const LOCALE_FILES: {
+    readonly af: "af_ZA";
+    readonly ar: "ar_SA";
+    readonly bn: "bn_BD";
+    readonly bg: "bg_BG";
+    readonly ca: "ca_ES";
+    readonly cs: "cs_CZ";
+    readonly da: "da_DK";
+    readonly de: "de_DE";
+    readonly el: "el_GR";
+    readonly "es-ES": "es_ES";
+    readonly fi: "fi_FI";
+    readonly fr: "fr_FR";
+    readonly he: "he_IL";
+    readonly hi: "hi_IN";
+    readonly hu: "hu_HU";
+    readonly id: "id_ID";
+    readonly it: "it_IT";
+    readonly ja: "ja_JP";
+    readonly ko: "ko_KR";
+    readonly nl: "nl_NL";
+    readonly no: "no_NO";
+    readonly pl: "pl_PL";
+    readonly "pt-PT": "pt_PT";
+    readonly "pt-BR": "pt_BR";
+    readonly ro: "ro_RO";
+    readonly ru: "ru_RU";
+    readonly sr: "sr_SP";
+    readonly "sv-SE": "sv_SE";
+    readonly th: "th_TH";
+    readonly tr: "tr_TR";
+    readonly uk: "uk_UA";
+    readonly vi: "vi_VN";
+    readonly "zh-CN": "zh_CN";
+    readonly "zh-TW": "zh_TW";
+};
+/**
+ * Loads a plugin namespace. Set by the plugin loader; until then a plugin
+ * namespace resolves to nothing and keys fall back to core.
+ */
+export type PluginLocaleResolver = (namespace: string, language: string, file: string) => Promise<ResourceKey | null>;
+export declare function setPluginLocaleResolver(resolver: PluginLocaleResolver | null): void;
+export declare const supportedLngs: string[];
+/** Core strings. Each plugin gets a namespace named after its id. */
+export declare const CORE_NAMESPACE = "translation";
+export declare function normalizeLanguageCode(language?: string | null): string;
+export declare function changeAppLanguage(language: string): Promise<string>;
+export declare function rememberLoginLanguage(language: string): string;
+export declare function consumeLoginLanguage(): string | null;
+export default i18n;

package/dist/host/types/src/ui/lib/ServerStatusContext.d.ts

@@ -0,0 +1,33 @@
+import React from "react";
+import { type ServerStatusEntry, type StatusValue } from "./server-status-store";
+interface ServerStatusContextType {
+    statuses: Map<number, ServerStatusEntry>;
+    initialLoadComplete: boolean;
+    refreshStatuses: () => Promise<void>;
+    /** "unknown" until the host has been checked. */
+    getStatus: (hostId: number) => StatusValue;
+}
+/** A host's live status outside React. "unknown" with no provider mounted. */
+export declare function getLiveHostStatus(hostId: number): StatusValue;
+export declare function ServerStatusProvider({ children, isAuthenticated, }: {
+    children: React.ReactNode;
+    isAuthenticated?: boolean;
+}): React.JSX.Element;
+export declare function useServerStatus(): ServerStatusContextType;
+/**
+ * Subscribe to a single host's status. Only re-renders when that host's
+ * status changes. Null when status checks are off for the host.
+ */
+export declare function useHostStatus(hostId: number, statusCheckEnabled?: boolean): StatusValue | null;
+/** Meta flags without depending on the full status map. */
+export declare function useServerStatusMeta(): {
+    initialLoadComplete: boolean;
+};
+/**
+ * One host's status for plugin views, which can render outside the app shell
+ * (a standalone window). Null there, and while the host has not been checked.
+ */
+export declare function useOptionalHostStatusEntry(hostId: number | undefined): {
+    status: "online" | "offline";
+} | null;
+export {};