@termix-ssh/plugin-sdk 1.0.0

package/dist/host/types/src/ui/plugin-host/shell-bridge.d.ts

@@ -0,0 +1,67 @@
+import type { Host } from "../../types/ui-types";
+import type { TabShellCallbacks } from "../shell/tab-registry";
+/**
+ * The live shell, as plugins see it.
+ *
+ * AppShell owns tabs and hosts in React state. It publishes callbacks and
+ * the host list here on every render, and plugin code (the app object, the
+ * SDK hooks, registered host actions) calls through this module, so nothing
+ * has to be threaded through props into a plugin.
+ */
+type Layout = {
+    version: number;
+    [key: string]: unknown;
+};
+export interface ShellLayoutProvider {
+    getLayout: () => Layout | null;
+    applyLayout: (layout: Layout, options?: {
+        name?: string;
+    }) => Promise<{
+        skipped: string[];
+    }>;
+}
+export declare function setShellCallbacks(next: TabShellCallbacks | null): void;
+export declare function setShellLayoutProvider(next: ShellLayoutProvider | null): void;
+export declare function setShellHosts(next: Host[], loaded?: boolean): void;
+export declare function useShellHosts(): {
+    hosts: Host[];
+    loaded: boolean;
+};
+export declare function notifyTabsChanged(): void;
+/** Called once the shell has restored its tabs. Late listeners fire at once. */
+export declare function notifyShellReady(): void;
+/**
+ * A plugin hands back the typed record it got from the SDK, which carries
+ * fewer fields than the shell's own host. A tab should get the shell's host,
+ * with whatever the plugin set on top.
+ */
+export declare function withShellHost(host: Host | null): Host | null;
+/** The shell's own copy of a saved host, with every plugin's settings. */
+export declare function shellHost(id: string | number | undefined): Host | undefined;
+/** Forwards to the mounted shell; a no-op before it mounts or after logout. */
+export declare const shell: TabShellCallbacks;
+export declare const tabsApi: {
+    openTab: (host: Host | null, type: string, options?: {
+        label?: string;
+        forceNewTab?: boolean;
+        data?: Record<string, unknown>;
+    }) => void;
+    openSingletonTab: (type: string, options?: {
+        label?: string;
+        data?: Record<string, unknown>;
+    }) => void;
+    connectHost: (host: Host, type?: string) => void;
+    closeTab: (tabId: string) => void;
+    openRailView: (id: string) => void;
+    getLayout: () => Layout;
+    applyLayout: (layout: Layout, options?: {
+        name?: string;
+    }) => Promise<{
+        skipped: string[];
+    }>;
+    onChange: (listener: () => void) => () => void;
+    onReady: (listener: () => void) => () => void;
+};
+/** Test seam, and on logout. */
+export declare function resetShellBridge(): void;
+export {};

package/dist/host/types/src/ui/plugin-host/view-ownership.d.ts

@@ -0,0 +1,31 @@
+import { type PluginRecord } from "./plugin-store";
+/**
+ * Who owns a tab type, rail view or dashboard card.
+ *
+ * Read from the manifests in GET /plugins rather than from what registered,
+ * because a disabled plugin never runs its frontend and so never registers
+ * anything, yet a saved tab or card of its still has to say whose it is.
+ */
+export type ViewKind = "tab" | "panel" | "card";
+export type ViewStatus = 
+/** Registered by a running plugin. */
+"ready"
+/** Owner is enabled but its frontend has not finished loading. */
+ | "loading"
+/** Owner is installed but switched off. */
+ | "disabled"
+/** Owner's frontend or backend failed, or a hard dependency is missing. */
+ | "failed"
+/** Nobody we know of declares this view. */
+ | "missing";
+export declare function viewOwner(kind: ViewKind, id: string): PluginRecord | undefined;
+/** Whether a manifest declares the id, i.e. the plugin may register it. */
+export declare function manifestDeclares(contributes: PluginRecord["summary"]["contributes"], kind: ViewKind, id: string): boolean;
+/**
+ * Status of a view that is NOT currently registered. Callers check their
+ * registry first; this explains why it is absent.
+ */
+export declare function unregisteredViewStatus(kind: ViewKind, id: string): {
+    status: Exclude<ViewStatus, "ready">;
+    owner?: PluginRecord;
+};

package/dist/host/types/src/ui/settings/HostPluginSections.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Host editor sections contributed by plugins.
+ *
+ * A plugin declares host-scope fields in its manifest and core draws them, so
+ * a plugin cannot ship its own form styling and a section disappears when its
+ * plugin does. The enable switch comes first and gates the rest, which is the
+ * shape the hardcoded feature tabs already have.
+ *
+ * Nothing is rendered when no enabled plugin declares host settings, so the
+ * group does not appear as an empty tab.
+ */
+import { type PluginSummary } from "../api/plugins-api";
+/** Values for every plugin on one host: { [pluginId]: { [key]: value } }. */
+export type HostPluginSettings = Record<string, Record<string, unknown>>;
+/** Enabled plugins declaring host-scope settings. */
+export declare function usePluginHostSections(): PluginSummary[];
+export interface HostPluginSectionsProps {
+    plugins: PluginSummary[];
+    values: HostPluginSettings;
+    setValue: (pluginId: string, key: string, value: unknown) => void;
+}
+export declare function HostPluginSections({ plugins, values, setValue, }: HostPluginSectionsProps): import("react").JSX.Element;
+export interface HostFeatureFieldsProps {
+    form: any;
+    updateForm: (patch: (form: Record<string, unknown>) => Record<string, unknown>) => void;
+}
+/**
+ * The calling plugin's manifest host settings, for a plugin that registered
+ * its own host editor section and so gets no generated tab.
+ */
+export declare function HostFeatureFields({ form, updateForm, }: HostFeatureFieldsProps): import("react").JSX.Element;

package/dist/host/types/src/ui/settings/SettingsFields.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One control per declared settings field type.
+ *
+ * A plugin supplies data; core draws the form. That is what keeps every
+ * plugin's settings page looking like the rest of the app, and what makes a
+ * page disappear cleanly when its plugin does.
+ */
+import { type PluginSettingsField } from "../api/plugins-api";
+export interface SettingsFieldProps {
+    pluginId: string;
+    field: PluginSettingsField;
+    values: Record<string, unknown>;
+    setValue: (key: string, value: unknown) => void;
+    /** Whether the owning plugin is running. */
+    running: boolean;
+    /** Message from a rejected save, shown under the control. */
+    error?: string;
+    disabled?: boolean;
+    /** In the host editor, the host default this field is ("pluginId.key"). */
+    defaultKey?: string;
+}
+export declare function SettingsFieldRow({ pluginId, field, values, setValue, running, error, disabled, defaultKey, }: SettingsFieldProps): import("react").JSX.Element;

package/dist/host/types/src/ui/settings/host-feature-tabs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gives every feature with manifest-declared host settings its own host editor
+ * tab, named after the feature. A plugin that registered its own host editor
+ * section already edits its settings there, so it gets no generated tab.
+ *
+ * Re-run whenever the plugin list changes so tabs come and go without a reload.
+ */
+import type { PluginSummary } from "../api/plugins-api";
+export declare function hostFeatureTabId(pluginId: string): string;
+/** Adds, updates and removes generated tabs to match the plugin list. */
+export declare function syncHostFeatureTabs(plugins: PluginSummary[]): string[];

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

@@ -0,0 +1,32 @@
+/**
+ * Components behind a `type: "custom"` settings field.
+ *
+ * Most settings are expressible as a schema, and those are rendered from the
+ * manifest so a plugin cannot ship its own form styling. A few are not: a
+ * device browser, a provider list. Those declare a component id here instead,
+ * which keeps the escape hatch narrow and named rather than letting a plugin
+ * hand core arbitrary markup. A plugin registers them from its frontend
+ * through `app.registerSettingsComponent`.
+ */
+import type { ComponentType } from "react";
+export interface SettingsComponentProps {
+    pluginId: string;
+    /** Current values for the scope this field sits in. */
+    values: Record<string, unknown>;
+    /** Writes one key in the same scope. */
+    setValue: (key: string, value: unknown) => void;
+    /** Whether the owning plugin is running. */
+    running: boolean;
+}
+export type SettingsComponent = ComponentType<SettingsComponentProps>;
+export declare function registerSettingsComponent(pluginId: string, componentId: string, component: SettingsComponent): () => void;
+export declare function getSettingsComponent(pluginId: string, componentId: string | undefined): SettingsComponent | undefined;
+/** Registered "<pluginId>:<componentId>" keys. */
+export declare function listSettingsComponents(): string[];
+/** Re-renders when components are registered, e.g. after a plugin loads. */
+export declare const useSettingsComponents: () => {
+    id: string;
+    component: SettingsComponent;
+}[];
+/** Test helper. */
+export declare function resetSettingsComponents(): void;

package/dist/host/types/src/ui/settings/settings-fields-util.d.ts

@@ -0,0 +1,11 @@
+import type { PluginSettingsField } from "../api/plugins-api";
+/**
+ * Whether the generic form draws a field: not hidden (the plugin edits it in
+ * its own UI) and its `requires` gate satisfied.
+ *
+ * Kept out of the component file so both the settings page and the host editor
+ * section can import it without dragging a component along.
+ */
+export declare function isFieldShown(field: PluginSettingsField, values: Record<string, unknown>): boolean;
+/** Whether a plugin has any field the generic form would ever draw. */
+export declare function hasVisibleFields(fields: PluginSettingsField[]): boolean;

package/dist/host/types/src/ui/shell/ActionSlot.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+import { type SlotContribution } from "./action-registry";
+interface ActionSlotProps {
+    slotId: string;
+    /**
+     * Arguments for the action, read at click time rather than on render. A
+     * getter keeps expensive context (a serialized terminal buffer, say) off the
+     * render path.
+     */
+    context?: () => unknown[];
+    /** Applied to the default button so a slot owner can match its own controls. */
+    className?: string;
+    /** Hides the whole slot. For a surface that is contextually unavailable. */
+    enabled?: boolean;
+    /** Renders a contribution the owner's own way instead of as a button. */
+    renderItem?: (contribution: SlotContribution, invoke: () => void) => React.ReactNode;
+    /** Icon-only, for toolbars that collapse their labels. */
+    hideLabels?: boolean;
+    /** Passed to each contribution's `when`. */
+    when?: Record<string, unknown>;
+}
+/**
+ * Renders whatever plugins have contributed to a named slot.
+ *
+ * Renders null when there is nothing to show, which covers both "no plugin
+ * contributed" and "the user may not see what was contributed". Those two
+ * cases are deliberately identical in the DOM: no placeholder, no disabled
+ * button, nothing hinting at a feature the user cannot reach.
+ */
+export declare function ActionSlot({ slotId, context, className, enabled, renderItem, hideLabels, when, }: ActionSlotProps): React.JSX.Element;
+/**
+ * Renders the component contributions in a slot, each with the owner's
+ * props. Same permission and `when` filtering as buttons, and the same
+ * nothing-at-all output when there is nothing to show.
+ */
+export declare function ComponentSlot({ slotId, props, when, }: {
+    slotId: string;
+    props?: Record<string, unknown>;
+    when?: Record<string, unknown>;
+}): React.JSX.Element;
+export {};

package/dist/host/types/src/ui/shell/TabContext.d.ts

@@ -0,0 +1,30 @@
+import React, { type ReactNode } from "react";
+import type { TabContextTab } from "../../types/index";
+export type Tab = TabContextTab;
+interface TabContextType {
+    tabs: Tab[];
+    currentTab: number | null;
+    allSplitScreenTab: number[];
+    addTab: (tab: Omit<Tab, "id">) => number;
+    removeTab: (tabId: number) => void;
+    setCurrentTab: (tabId: number) => void;
+    setSplitScreenTab: (tabId: number) => void;
+    getTab: (tabId: number) => Tab | undefined;
+    reorderTabs: (fromIndex: number, toIndex: number) => void;
+    updateHostConfig: (hostId: number, newHostConfig: {
+        id: number;
+        name?: string;
+        username: string;
+        ip: string;
+        port: number;
+    }) => void;
+    updateTab: (tabId: number, updates: Partial<Omit<Tab, "id">>) => void;
+}
+export declare function useTabs(): TabContextType;
+export declare function useTabsSafe(): TabContextType;
+interface TabProviderProps {
+    children: ReactNode;
+}
+export declare function clearTermixSessionStorage(): void;
+export declare function TabProvider({ children }: TabProviderProps): React.JSX.Element;
+export {};

package/dist/host/types/src/ui/shell/action-registry.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Runtime registry for plugin-contributed UI actions and the slots they fill.
+ *
+ * This is the frontend sibling of src/backend/plugins/service-registry.ts, and
+ * the difference between them is the thing to be clear about:
+ *
+ *   - The backend registry's proxy IS a boundary. It checks the acting user's
+ *     RBAC permission on every call before the provider ever runs.
+ *   - This one is NOT. It runs in the browser, where anyone can call
+ *     invokeAction from the console. The permission attached to an action
+ *     decides whether a button is DRAWN, nothing more.
+ *
+ * Real enforcement stays where it already is: the backend route the handler
+ * eventually calls. Treating this file as a security boundary is the easy
+ * mistake to make when reading the two side by side, so it is said plainly
+ * here rather than left to be inferred.
+ *
+ * Unlike the rail and tab registries (rail-items.ts, tabUtils.tsx), which are
+ * plain Maps read during render, this one is reactive. A slot renders live and
+ * has to react when a plugin is enabled or disabled at runtime, so it carries
+ * subscribe/getSnapshot plumbing for useSyncExternalStore.
+ */
+import type { ComponentType } from "react";
+/**
+ * Args are unknown[] because the registry never inspects them: a slot owner
+ * passes whatever its surface offers (the terminal passes its buffer text) and
+ * the contributing plugin knows what to expect. Handlers are written with
+ * concrete parameter types, so registerAction accepts those too.
+ */
+export type ActionHandler = (...args: never[]) => unknown;
+export interface RegisteredAction {
+    id: string;
+    handler: ActionHandler;
+    /** Role permission a user needs before this action is offered. */
+    permission?: string;
+    pluginId?: string;
+}
+export interface ActionSlotDefinition {
+    id: string;
+    /** Contribution kinds this slot will render. */
+    accepts: string[];
+}
+export interface SlotContribution {
+    /** Action invoked when this contribution is activated. */
+    actionId: string;
+    titleKey: string;
+    /** Secondary text, for slots that show one (onboarding cards). */
+    descriptionKey?: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Checked against the slot's accepts. Defaults to "button". */
+    kind?: string;
+    /**
+     * For kind "component": rendered by the slot owner with its own props,
+     * e.g. a panel docked into the terminal.
+     */
+    component?: ComponentType<Record<string, unknown>>;
+    /** Extra condition, evaluated against the slot owner's context. */
+    when?: (context: Record<string, unknown>) => boolean;
+    pluginId?: string;
+    /** Lower sorts first. Ties break on actionId so ordering is stable. */
+    order?: number;
+}
+export declare function registerAction(id: string, handler: ActionHandler, options?: {
+    permission?: string;
+    pluginId?: string;
+}): () => void;
+/** Every registered action. */
+export declare function listActions(): RegisteredAction[];
+/** Whether a handler is registered, i.e. its plugin is running. */
+export declare function isActionRegistered(id: string): boolean;
+/** The permission gating an action, if it declared one. */
+export declare function getActionPermission(id: string): string | undefined;
+/**
+ * Runs an action. Resolves quietly when the id is unknown: a contribution can
+ * outlive the plugin that registered its handler, and a click should not throw
+ * into the React event handler because of it.
+ */
+export declare function invokeAction(id: string, ...args: unknown[]): Promise<unknown>;
+export declare function declareActionSlot(slot: ActionSlotDefinition): () => void;
+/**
+ * Adds a contribution to a slot.
+ *
+ * A contribution for a slot nobody has declared yet is kept rather than
+ * dropped: plugin activation order is not guaranteed, and the slot owner may
+ * register after the contributor. It becomes visible once the slot appears.
+ */
+export declare function registerSlotContribution(slotId: string, contribution: SlotContribution): () => void;
+export declare function unregisterSlotContribution(slotId: string, actionId: string): void;
+/**
+ * Contributions for a slot, sorted and referentially stable between changes.
+ * Unfiltered: callers that render go through useActionSlot, which drops the
+ * ones the current user may not see.
+ */
+export declare function getSlotContributions(slotId: string): SlotContribution[];
+export declare function subscribeToActionRegistry(listener: () => void): () => void;
+/** Test seam, mirroring resetPluginState(). */
+export declare function resetActionRegistry(): void;

package/dist/host/types/src/ui/shell/keybinding-registry.d.ts

@@ -0,0 +1,62 @@
+import type { ComponentType } from "react";
+import type { KeybindingAction, KeyCombo } from "../../types/keybindings";
+export interface KeybindingEditorProps {
+    action: KeybindingAction;
+    onChange: (action: KeybindingAction) => void;
+}
+export interface KeybindingRunContext {
+    sessionId?: string;
+    host?: {
+        ip?: string;
+        username?: string;
+        port?: number | string;
+        name?: string;
+    } | null;
+    send?: (data: string) => void;
+}
+/**
+ * An action a key can be bound to. The shell registers its own; plugins add
+ * theirs with app.registerKeybindingAction. `id` is what a saved binding
+ * stores as action.type.
+ */
+export interface KeybindingActionDef {
+    id: string;
+    pluginId?: string;
+    /** A full translation key. */
+    labelKey: string;
+    scope: "session" | "global";
+    editor?: ComponentType<KeybindingEditorProps>;
+    summary?: ComponentType<KeybindingEditorProps>;
+    /** A full translation key when the action cannot be saved yet. */
+    validate?: (action: KeybindingAction) => string | null;
+    run?: (action: KeybindingAction, context: KeybindingRunContext) => void;
+    order?: number;
+}
+/** A built-in key the user can rebind. */
+export interface KeybindingDefaultDef {
+    id: string;
+    pluginId?: string;
+    combo: KeyCombo;
+    /** A full translation key. */
+    descriptionKey: string;
+    order?: number;
+}
+/** Fired for the shell's own actions; AppShell runs them. */
+export declare const GLOBAL_KEYBINDING_EVENT = "termix:global-keybinding";
+export declare const SHELL_KEYBINDING_ACTION_IDS: string[];
+/** Adds a plugin's action. A shell action's id cannot be taken over. */
+export declare function registerKeybindingAction(action: KeybindingActionDef): () => void;
+export declare const registerKeybindingDefault: (item: KeybindingDefaultDef) => () => void;
+export declare const listKeybindingActions: () => KeybindingActionDef[];
+export declare const useKeybindingActions: () => KeybindingActionDef[];
+export declare const getKeybindingAction: (id: string) => KeybindingActionDef;
+export declare const listKeybindingDefaults: () => KeybindingDefaultDef[];
+export declare const useKeybindingDefaults: () => KeybindingDefaultDef[];
+/** Back to the shell's own actions and no defaults, for tests. */
+export declare function resetKeybindingRegistry(): void;
+/**
+ * Runs a bound action through whoever registered it. False when nothing
+ * running handles its type (its plugin is off), so the caller can let the
+ * key through.
+ */
+export declare function runKeybindingAction(action: KeybindingAction, context?: KeybindingRunContext): boolean;

package/dist/host/types/src/ui/shell/palette-registry.d.ts

@@ -0,0 +1,55 @@
+import type { ComponentType } from "react";
+import type { Host, Tab } from "../../types/ui-types";
+import type { TabShellCallbacks } from "./tab-registry";
+/** A command palette entry a plugin contributes. */
+export interface PaletteEntryDef {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    keywords?: string[];
+    scope: "global" | "host";
+    when?: (host?: Host) => boolean;
+    run: (shell: TabShellCallbacks, host?: Host) => void;
+    order?: number;
+}
+export declare const registerPaletteEntry: (item: PaletteEntryDef) => () => void;
+export declare const usePaletteEntries: () => PaletteEntryDef[];
+export declare const listPaletteEntries: () => PaletteEntryDef[];
+export declare const resetPaletteEntries: () => void;
+export declare function paletteEntriesFor(all: PaletteEntryDef[], scope: PaletteEntryDef["scope"], host?: Host): PaletteEntryDef[];
+/** One row of a palette group. */
+export interface PaletteItemDef {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    keywords?: string[];
+    needsTarget?: boolean;
+    hint?: string;
+    run: (context: {
+        targetTab?: Tab;
+        shell: TabShellCallbacks;
+    }) => void;
+}
+/** A searchable group of items a plugin fills, e.g. its saved commands. */
+export interface PaletteGroupDef {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    order?: number;
+    load: () => PaletteItemDef[] | Promise<PaletteItemDef[]>;
+    showWhenEmpty?: boolean;
+}
+export declare const registerPaletteGroup: (item: PaletteGroupDef) => () => void;
+export declare const usePaletteGroups: () => PaletteGroupDef[];
+export declare const listPaletteGroups: () => PaletteGroupDef[];
+export declare const resetPaletteGroups: () => void;
+/** A group's items, or none when its loader throws. */
+export declare function loadPaletteGroup(group: PaletteGroupDef): Promise<PaletteItemDef[]>;
+/** The items the query matches, by title, description or keyword. */
+export declare function filterPaletteItems(items: PaletteItemDef[], query: string, showWhenEmpty?: boolean): PaletteItemDef[];

package/dist/host/types/src/ui/shell/panel-registry.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentType } from "react";
+import type { TabShellCallbacks } from "./tab-registry";
+export interface PanelRenderProps {
+    /** The command-target tab the user is working in, if any. */
+    targetTab?: import("../../types/ui-types").Tab;
+    active: boolean;
+    shell: TabShellCallbacks;
+    setEditing: (editing: boolean) => void;
+    activeTabType?: string;
+    placement: "left" | "right" | "tab";
+}
+/** Sidebar content for a rail view a plugin contributes. */
+export interface PanelDef {
+    id: string;
+    pluginId?: string;
+    component: ComponentType<PanelRenderProps>;
+    /** Stays mounted once opened, so its state survives switching away. */
+    keepMounted?: boolean;
+}
+export declare const registerPanel: (item: PanelDef) => () => void;
+export declare const getPanel: (id: string) => PanelDef;
+export declare const listPanels: () => PanelDef[];
+export declare const usePanels: () => PanelDef[];
+export declare const resetPanels: () => void;

package/dist/host/types/src/ui/shell/tab-registry.d.ts

@@ -0,0 +1,92 @@
+import type { ConfirmOptions } from "../components/surface/surface-scope";
+import type { ComponentType, Ref } from "react";
+import type { HostDraft } from "@termix-ssh/plugin-sdk/frontend";
+import type { Host, Tab } from "../../types/ui-types";
+/**
+ * The shell callbacks a registered tab may use. Same bag every tab gets, so
+ * a plugin tab can do anything a core tab can without new positional props.
+ */
+export interface TabShellCallbacks {
+    openTab: (host: Host | null, type: string, options?: {
+        label?: string;
+        forceNewTab?: boolean;
+        data?: Record<string, unknown>;
+    }) => void;
+    openSingletonTab: (type: string, options?: {
+        label?: string;
+        data?: Record<string, unknown>;
+    }) => void;
+    /** Connects the way clicking the host in the host list does. */
+    connectHost: (host: Host, type?: string) => void;
+    closeTab: (tabId: string) => void;
+    renameTab: (tabId: string, label: string) => void;
+    openRailView: (id: string) => void;
+    /** Closes a rail view wherever it is shown, e.g. when its feature goes away. */
+    closeRailView: (id: string) => void;
+    /** Opens the host editor for a new host with these fields filled in. */
+    openHostEditor?: (draft?: HostDraft) => void;
+    /** Saves a quick-connect tab's host. Core terminal only. */
+    saveQuickConnect?: (tab: Tab, host: Host) => Promise<void>;
+    /** Asks a yes or no question over the main area. */
+    confirm?: (options: ConfirmOptions) => Promise<boolean>;
+}
+export interface TabRenderProps {
+    tab: Tab;
+    host?: Host;
+    /** The host in the shape SSH-facing components take. */
+    sshHost?: Record<string, unknown>;
+    label: string;
+    isVisible: boolean;
+    isFocusedPane: boolean;
+    inSplit?: boolean;
+    handleRef: Ref<unknown>;
+    shell: TabShellCallbacks;
+}
+export interface StandaloneViewProps {
+    hostId?: string;
+    view: string;
+    params: URLSearchParams;
+}
+export interface TabTypeDef {
+    /** The tab type. */
+    id: string;
+    pluginId?: string;
+    component: ComponentType<TabRenderProps>;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    titleKey?: string;
+    requiresHost?: boolean;
+    noHostMessageKey?: string;
+    persistent?: boolean;
+    singleton?: boolean;
+    session?: boolean;
+    hostless?: boolean;
+    restore?: (host: Host) => boolean;
+    activityTypes?: string[];
+    standalone?: ComponentType<StandaloneViewProps>;
+    standaloneViews?: string[];
+    panelFrame?: boolean;
+    /** False keeps this tab out of saved layouts and workspaces. */
+    inLayouts?: boolean;
+    /** Panels that type into a terminal act on the last one of these focused. */
+    commandTarget?: boolean;
+    /** Paints its own background; its frame stays transparent. */
+    ownBackground?: boolean;
+    /** Every open is a new tab. */
+    multiInstance?: boolean;
+    preload?: () => Promise<unknown>;
+}
+export declare const registerTabType: (item: TabTypeDef) => () => void;
+export declare const getTabType: (id: string) => TabTypeDef;
+export declare const listTabTypes: () => TabTypeDef[];
+export declare const useTabTypes: () => TabTypeDef[];
+export declare const resetTabTypes: () => void;
+export declare function isPersistentTabType(type: string): boolean;
+export declare function isSessionTabType(type: string): boolean;
+/** Whether a saved tab of this type may be restored for this host. */
+export declare function canRestoreTabType(type: string, host: Host | undefined): boolean;
+/** The tab type a recent-activity entry opens, if a registered tab claims it. */
+export declare function tabTypeForActivity(activityType: string): TabTypeDef | undefined;
+/** The registered tab serving a `?view=` full-screen link. */
+export declare function standaloneViewFor(view: string): TabTypeDef | undefined;