@termix-ssh/plugin-sdk 1.0.0 → 1.0.2

package/dist/host/{chunk-XGWE7BTJ.js → chunk-XKMRKQFN.js}

@@ -21,7 +21,7 @@ var inFlight = null;
 function load() {
   if (cache) return Promise.resolve(cache);
   if (inFlight) return inFlight;
-  inFlight = import("./rbac-api-6KDMBVDZ.js").then(({ getMyPermissions }) => getMyPermissions()).then((result) => {
+  inFlight = import("./rbac-api-JKISXZEP.js").then(({ getMyPermissions }) => getMyPermissions()).then((result) => {
     cache = {
       permissions: result.permissions ?? [],
       isAdmin: !!result.isAdmin
@@ -39,6 +39,10 @@ async function hasPermission(permission) {
   const { permissions, isAdmin } = await load();
   return matchesPermission(permissions, isAdmin, permission);
 }
+async function loadPermissionChecker() {
+  const { permissions, isAdmin } = await load();
+  return (permission) => matchesPermission(permissions, isAdmin, permission);
+}
 function preloadPermissions() {
   return load().then(() => void 0);
 }
@@ -82,6 +86,7 @@ function setPermissionsForTesting(permissions, isAdmin = false) {
 
 export {
   hasPermission,
+  loadPermissionChecker,
   preloadPermissions,
   notifyPermissionsChanged,
   usePermissions,

package/dist/host/{linked-server-FZGWQW32.js → linked-server-DW5P3NLZ.js}

@@ -3,7 +3,7 @@ import {
   SYNC_CHANGED_EVENT,
   getLinkedSession,
   notifySyncChanged
-} from "./chunk-F3SDZDDG.js";
+} from "./chunk-LKYAVM4T.js";
 import "./chunk-YC2MAKSP.js";
 export {
   SYNC_CHANGED_EVENT,

package/dist/host/{rbac-api-6KDMBVDZ.js → rbac-api-JKISXZEP.js}

@@ -23,7 +23,7 @@ import {
   shareHost,
   updateHostAccess,
   updateRole
-} from "./chunk-F3SDZDDG.js";
+} from "./chunk-LKYAVM4T.js";
 import "./chunk-YC2MAKSP.js";
 export {
   assignRoleToUser,

package/dist/host/testing-host.js

@@ -32,6 +32,7 @@ import {
   listSettingsComponents,
   loadPaletteGroup,
   notifyShellReady,
+  onboardingSteps,
   registeredDashboardCardList,
   resetShellBridge,
   setPluginApiForTesting,
@@ -39,16 +40,16 @@ import {
   setShellCallbacks,
   setShellHosts,
   setShellLayoutProvider
-} from "./chunk-XH5NXL6Y.js";
+} from "./chunk-SS43S6VI.js";
 import {
   setPermissionsForTesting
-} from "./chunk-XGWE7BTJ.js";
+} from "./chunk-XKMRKQFN.js";
 import {
   getTabType,
   listTabTypes,
   setFrontendState,
   setPluginSummaries
-} from "./chunk-F3SDZDDG.js";
+} from "./chunk-LKYAVM4T.js";
 import "./chunk-YC2MAKSP.js";
 
 // src/ui/plugin-host/testing-host.tsx
@@ -61,7 +62,8 @@ var CORE_UNSAVED = /* @__PURE__ */ new Set([
   "settings",
   "user-profile",
   "admin-settings",
-  "split-screen"
+  "split-screen",
+  "plugins"
 ]);
 function isUnregisteredPluginTabType(type) {
   return !CORE_UNSAVED.has(type) && !getTabType(type);
@@ -191,6 +193,7 @@ async function renderPlugin(plugin, options = {}) {
   setFrontendState(pluginId, "active");
   if (options.ready) notifyShellReady();
   const mine = (items) => items.filter((item) => item.pluginId === pluginId);
+  const unprefixed = (items) => mine(items).map((item) => item.id.slice(pluginId.length + 1));
   const tabRecord = (type, host) => ({
     id: `${type}-test`,
     instanceId: `${type}-test`,
@@ -230,7 +233,8 @@ async function renderPlugin(plugin, options = {}) {
       secondFactors: () => mine(listSecondFactorUIs()).map((factor) => factor.id),
       paletteGroups: () => mine(listPaletteGroups()).map((group) => group.id),
       keybindingActions: () => mine(listKeybindingActions()).map((action) => action.id),
-      keybindingDefaults: () => mine(listKeybindingDefaults()).map((binding) => binding.id)
+      keybindingDefaults: () => mine(listKeybindingDefaults()).map((binding) => binding.id),
+      onboardingSteps: () => unprefixed(onboardingSteps.list())
     },
     async loadPaletteGroup(id) {
       const group = listPaletteGroups().find((entry) => entry.id === id) ?? missing("a palette group", id);
@@ -303,6 +307,35 @@ async function renderPlugin(plugin, options = {}) {
       if (!Component) missing(`an extension "${component}" component`, id);
       return wrap(/* @__PURE__ */ jsx(Component, { ...props }));
     },
+    renderOnboardingStep(id, props = {}) {
+      const step = onboardingSteps.get(`${pluginId}:${id}`) ?? missing("an onboarding step", id);
+      const Component = step.Component;
+      let canContinue = true;
+      let beforeNext = null;
+      const element = wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            mode: "full",
+            isAdmin: true,
+            isDesktop: false,
+            shellReady: false,
+            setCanContinue: (ok) => {
+              canContinue = ok;
+            },
+            setBeforeNext: (fn) => {
+              beforeNext = fn;
+            },
+            ...props
+          }
+        )
+      );
+      return {
+        element,
+        canContinue: () => canContinue,
+        next: async () => beforeNext ? await beforeNext() : true
+      };
+    },
     renderDashboardCard(id) {
       const card = getRegisteredDashboardCard(id) ?? missing("a card", id);
       const Component = card.component;

package/dist/host/types/src/types/credential-sidebar-preferences.d.ts

@@ -19,7 +19,18 @@ export interface CredentialSidebarFilterState {
     type: string[];
     tags: string[];
 }
-export interface CredentialSidebarDisplayPreferences {
+/** Which parts of a credential row are shown. */
+export interface CredentialRowFields {
+    showUsername: boolean;
+    /** The "3h" count of hosts using it. */
+    showUsageCount: boolean;
+    showTypeBadge: boolean;
+    showPinIcon: boolean;
+    showSharedBadge: boolean;
+}
+export declare const CREDENTIAL_ROW_FIELD_KEYS: (keyof CredentialRowFields)[];
+export declare function defaultCredentialRowFields(): CredentialRowFields;
+export interface CredentialSidebarDisplayPreferences extends CredentialRowFields {
     density: CredentialDensity;
     showTags: boolean;
     trayTrigger: CredentialTrayTrigger;

package/dist/host/types/src/types/host-sidebar-preferences.d.ts

@@ -29,7 +29,19 @@ export interface HostSidebarFilterState {
     features: string[];
     tags: string[];
 }
-export interface HostSidebarDisplayPreferences {
+/** Which parts of a host row are shown. */
+export interface HostRowFields {
+    showAddress: boolean;
+    showUsername: boolean;
+    showPort: boolean;
+    showPinIcon: boolean;
+    showSharedBadge: boolean;
+    /** Badges plugins add next to the name. */
+    showBadges: boolean;
+}
+export declare const HOST_ROW_FIELD_KEYS: (keyof HostRowFields)[];
+export declare function defaultHostRowFields(): HostRowFields;
+export interface HostSidebarDisplayPreferences extends HostRowFields {
     density: HostDensity;
     showTags: boolean;
     trayTrigger: HostTrayTrigger;
@@ -39,6 +51,11 @@ export interface HostSidebarDisplayPreferences {
     /** When false, nested folders hide the parent-path breadcrumb before their name. */
     showFolderPaths: boolean;
     hostClickBehavior: HostClickBehavior;
+    /**
+     * Host action id to whether it shows in the row's connect bar. An action
+     * missing here follows its own default. Every action stays in the menu.
+     */
+    barActions: Record<string, boolean>;
 }
 export interface HostSidebarPreferences {
     version: number;

package/dist/host/types/src/types/onboarding.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Onboarding step bookkeeping, shared by the frontend and the ui-preferences
+ * route. Dependency-free for the backend's NodeNext build.
+ *
+ * Each step has a key and a version. A user's `seen` map records the highest
+ * version of each step they have been shown, so bumping one step's version
+ * shows that step again (and only that step) to everyone who saw it before.
+ * Plugin steps are keyed `<pluginId>:<id>`.
+ */
+export declare const CORE_ONBOARDING_STEPS: {
+    readonly plugins: 1;
+    readonly "desktop-sync": 1;
+    readonly preset: 1;
+    readonly appearance: 1;
+    readonly security: 1;
+};
+export type CoreOnboardingStepKey = keyof typeof CORE_ONBOARDING_STEPS;
+/**
+ * What a user who finished the old single-version onboarding counts as
+ * having seen. Frozen on purpose: a later bump in CORE_ONBOARDING_STEPS must
+ * still show the bumped step to these users.
+ */
+export declare const LEGACY_SEEN: Readonly<Record<string, number>>;
+export declare const MAX_SEEN_ENTRIES = 500;
+export declare function pluginStepKey(pluginId: string, id: string): string;
+export declare function isValidSeenEntry(key: string, version: unknown): boolean;
+export declare function sanitizeSeen(input: unknown): Record<string, number>;
+/** Per-key max, so a stale tab never lowers what another tab recorded. */
+export declare function mergeSeen(a: Record<string, number> | undefined, b: Record<string, number> | undefined): Record<string, number>;

package/dist/host/types/src/types/plugin-onboarding.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The onboarding plugin picker: what the admin chose for each plugin, and the
+ * dependency rules that keep the result loadable. Shared by the picker (to
+ * show "kept because X needs it" live) and the backend apply route.
+ */
+export type PluginChoice = "enabled" | "disabled" | "remove";
+export declare const PLUGIN_CHOICES: readonly PluginChoice[];
+export interface ChoicePlugin {
+    id: string;
+    /** Hard dependencies (plugin ids). */
+    dependencies: string[];
+}
+export interface ChoiceAdjustment {
+    id: string;
+    from: PluginChoice;
+    to: PluginChoice;
+    /** The plugins whose choice forced this one up. */
+    requiredBy: string[];
+}
+export declare function isPluginChoice(value: unknown): value is PluginChoice;
+/**
+ * Raise choices until every plugin's dependencies can serve it: an enabled
+ * plugin needs its dependencies enabled, and a kept but disabled plugin
+ * needs them at least kept. Ids missing from `choices` stay as they are and
+ * are never adjusted.
+ */
+export declare function resolvePluginChoices(plugins: ChoicePlugin[], choices: Record<string, PluginChoice>): {
+    choices: Record<string, PluginChoice>;
+    adjustments: ChoiceAdjustment[];
+};
+/**
+ * The order to apply resolved choices in: enable dependencies first, and
+ * disable or remove dependents first.
+ */
+export declare function applyOrder(plugins: ChoicePlugin[], resolved: Record<string, PluginChoice>): {
+    enable: string[];
+    disable: string[];
+    remove: string[];
+};

package/dist/host/types/src/types/ui-preferences.d.ts

@@ -17,8 +17,6 @@
  */
 /** 2: the docker and host metrics areas moved to their plugins. */
 export declare const UI_PREFERENCES_VERSION = 3;
-/** Bump when onboarding gains steps existing users should be shown again. */
-export declare const UI_ONBOARDING_VERSION = 2;
 export type UiPreset = "simple" | "balanced" | "advanced" | "custom";
 export type UiAreaKey = "chrome" | "hostList" | "credentialList" | "rail" | "dashboard" | "hostEditor";
 export type UiDensity = "comfortable" | "compact";
@@ -50,6 +48,8 @@ export interface UiRailPreferences {
      * items are only known at runtime, so the preset cannot list them.
      */
     hidePluginItems?: boolean;
+    /** Rail item ids in the user's order. Items not listed keep their place. */
+    order?: string[];
 }
 export interface UiDashboardPreferences {
     enabledCards: string[];
@@ -73,10 +73,17 @@ export type UiOverrides = {
     [key: UiPluginAreaKey]: Record<string, unknown>;
 };
 export interface UiOnboardingState {
-    /** 0 means "never completed". Compared against UI_ONBOARDING_VERSION. */
-    completedVersion: number;
+    /** Step key to the highest version of that step the user was shown. */
+    seen: Record<string, number>;
+    /** When the first full run finished. Null means it never has. */
     completedAt: string | null;
     skipped: boolean;
+    /**
+     * Set for users carried over from the old single-version onboarding. The
+     * client marks every plugin step that exists right now as seen without
+     * showing it, then clears this.
+     */
+    baselinePending: boolean;
 }
 export interface UiPreferences {
     version: number;
@@ -87,6 +94,8 @@ export interface UiPreferences {
 export declare const PRESETS: Record<Exclude<UiPreset, "custom">, UiAreaPreferences>;
 export declare const UI_AREA_KEYS: UiAreaKey[];
 export declare function sanitizeUiOverrides(input: unknown): UiOverrides;
+export declare function defaultOnboardingState(): UiOnboardingState;
+export declare function sanitizeOnboarding(input: unknown): UiOnboardingState;
 export declare function defaultUiPreferences(): UiPreferences;
 export declare function sanitizeUiPreferences(input: unknown): UiPreferences;
 /**

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

@@ -128,7 +128,7 @@ export type HostFolder = {
     localOnly?: boolean;
 };
 /** Core's own tab types. Plugins register theirs at runtime. */
-type KnownTabType = "dashboard" | "host-manager" | "settings" | "user-profile" | "admin-settings" | "split-screen";
+type KnownTabType = "dashboard" | "host-manager" | "settings" | "user-profile" | "admin-settings" | "split-screen" | "plugins";
 /**
  * TabType covers every built-in tab plus any plugin-contributed tab id.
  * `string & {}` (rather than plain `string`) keeps IDE autocomplete

package/dist/host/types/src/ui/api/plugins-api.d.ts

@@ -1,3 +1,6 @@
+import type { ChoiceAdjustment, PluginChoice } from "../../types/plugin-onboarding";
+import type { ChangelogRelease, ReleaseNotes } from "@termix-ssh/plugin-sdk/changelog";
+export type { PluginChoice };
 export interface PluginTabContribution {
     id: string;
     titleKey: string;
@@ -124,5 +127,213 @@ export interface PluginSummary {
         http: string[];
         ws: string[];
     };
+    registryId?: string | null;
+    autoUpdate?: boolean;
+    pinnedVersion?: string | null;
+    channel?: PluginChannel;
+    description?: string;
+    author?: string;
+    repository?: string;
+    /** A YouTube video id from the manifest. Admins only. */
+    videoId?: string;
+    /** What the plugin does, from the manifest. Admins only. */
+    features?: string[];
+    signedBy?: string | null;
 }
 export declare function getPlugins(): Promise<PluginSummary[]>;
+/** Fired after any change to installed plugins; the loader resyncs on it. */
+export declare const PLUGINS_CHANGED_EVENT = "termix:plugins-changed";
+export type PluginChannel = "stable" | "beta";
+export interface RegistryPluginVersion {
+    version: string;
+    /** A beta, offered only to plugins on the beta channel. */
+    prerelease?: boolean;
+    compatible: boolean;
+    capabilities: string[];
+    publishedAt?: string;
+    releaseNotesUrl?: string;
+    notes?: ReleaseNotes;
+    size: number;
+}
+export interface RegistryPluginEntry {
+    id: string;
+    name: string;
+    description: string;
+    author: string;
+    category: string;
+    repository?: string;
+    icon?: string;
+    videoId?: string;
+    features?: string[];
+    versions: RegistryPluginVersion[];
+    /** Newest release on the plugin's channel. */
+    latestVersion: string | null;
+    /** Newest beta, when one is newer than stable. */
+    latestBeta?: string | null;
+    channel?: PluginChannel;
+    installed: boolean;
+    installedVersion: string | null;
+    updateAvailable: boolean;
+    addedCapabilities: string[];
+    pinnedVersion: string | null;
+    autoUpdate: boolean;
+    bundled: boolean;
+    /** Active installs when known, release downloads otherwise. */
+    installCount: number | null;
+    installCountSource: string | null;
+}
+export interface RegistryListing {
+    registry: {
+        id: string;
+        url: string;
+        lastCheckedAt: string | null;
+        error: string | null;
+    };
+    managedByServer: boolean;
+    plugins: RegistryPluginEntry[];
+}
+export interface PluginStateChange {
+    id: string;
+    enabled: boolean;
+    enable: string[];
+    disable: string[];
+    missing: string[];
+    state?: string;
+}
+export interface PluginDataSummary {
+    id: string;
+    tables: Array<{
+        name: string;
+        rows: number | null;
+    }>;
+    kvKeys: number;
+    settings: {
+        admin: number;
+        user: number;
+        host: number;
+        secret: number;
+    };
+    migrations: Array<{
+        id: string;
+        appliedAt: string | null;
+    }>;
+    grants: Array<{
+        capability: string;
+        source: string;
+        grantedAt: string | null;
+    }>;
+    filesBytes: number;
+}
+export interface UpdateAllResult {
+    updated: Array<{
+        id: string;
+        version: string;
+    }>;
+    needsReview: Array<{
+        id: string;
+        capabilities: string[];
+    }>;
+    failed: Array<{
+        id: string;
+        error: string;
+    }>;
+}
+export declare function getPluginRegistry(refresh?: boolean): Promise<RegistryListing>;
+/** `capabilities` is exactly what the consent prompt showed. */
+export declare function installPlugin(pluginId: string, options: {
+    version?: string;
+    capabilities: string[];
+}): Promise<{
+    id: string;
+    version: string;
+    state: string;
+}>;
+export declare function updatePlugin(pluginId: string, options?: {
+    version?: string;
+    acceptCapabilities?: boolean;
+    capabilities?: string[];
+}): Promise<{
+    id: string;
+    version: string;
+    state: string;
+}>;
+export declare function updateAllPlugins(): Promise<UpdateAllResult>;
+export declare function uninstallPlugin(pluginId: string): Promise<void>;
+export declare function previewPluginState(pluginId: string, enabled: boolean): Promise<PluginStateChange>;
+export declare function setPluginState(pluginId: string, enabled: boolean): Promise<PluginStateChange>;
+export declare function retryPlugin(pluginId: string): Promise<void>;
+export declare function setPluginOptions(pluginId: string, options: {
+    autoUpdate?: boolean;
+    pinned?: boolean;
+    channel?: PluginChannel;
+}): Promise<{
+    autoUpdate: boolean;
+    pinnedVersion: string | null;
+    channel: PluginChannel;
+}>;
+export declare function setAllPluginChannels(channel: PluginChannel): Promise<{
+    changed: string[];
+}>;
+export declare function getPluginData(pluginId: string): Promise<PluginDataSummary>;
+export declare function getPluginChangelog(pluginId: string): Promise<ChangelogRelease[]>;
+export declare function deletePluginData(pluginId: string): Promise<void>;
+export interface DeveloperModeState {
+    enabled: boolean;
+    /** TERMIX_REQUIRE_SIGNED_PLUGINS blocks file installs even in developer mode. */
+    signedOnly: boolean;
+}
+export declare function getDeveloperMode(): Promise<DeveloperModeState>;
+/** Fired after developer mode changes; detail is the new value. */
+export declare const DEVELOPER_MODE_CHANGED_EVENT = "termix:plugin-developer-mode";
+export declare function setDeveloperMode(enabled: boolean): Promise<void>;
+export interface PluginUploadPreview {
+    token: string;
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    features?: string[];
+    capabilities: string[];
+    replaces: string | null;
+}
+export declare function uploadPlugin(file: Blob): Promise<PluginUploadPreview>;
+export declare function installUploadedPlugin(token: string, capabilities: string[]): Promise<{
+    id: string;
+    version: string;
+    state: string;
+}>;
+export interface OnboardingPluginInfo {
+    id: string;
+    name: string;
+    description: string;
+    icon: string | null;
+    category: string;
+    version: string;
+    source: "bundled" | "user";
+    state: string;
+    dependencies: string[];
+    recommended: boolean;
+    consent: boolean;
+}
+export interface OnboardingPluginList {
+    pending: boolean;
+    /** On an upgrade the picker starts from what is on, not the defaults. */
+    reason: "fresh" | "upgrade" | null;
+    managedByLinkedServer: boolean;
+    plugins: OnboardingPluginInfo[];
+}
+export interface OnboardingApplyResult {
+    resolved: Record<string, PluginChoice>;
+    adjustments: ChoiceAdjustment[];
+    enabled: string[];
+    disabled: string[];
+    removed: string[];
+    failed: {
+        id: string;
+        error: string;
+        code?: string;
+    }[];
+}
+export declare function getOnboardingPlugins(): Promise<OnboardingPluginList>;
+export declare function applyOnboardingPlugins(choices: Record<string, PluginChoice>): Promise<OnboardingApplyResult>;

package/dist/host/types/src/ui/api/system-status-api.d.ts

@@ -29,6 +29,7 @@ export interface ReleasesRSSResponse {
 export declare function getReleasesRSS(perPage?: number): Promise<ReleasesRSSResponse>;
 export interface VersionInfo {
     status?: "up_to_date" | "requires_update" | "beta" | "unknown";
+    channel?: "stable" | "beta";
     /** Same value as remoteVersion; the endpoint sends both. */
     version?: string;
     localVersion?: string;
@@ -46,4 +47,27 @@ export interface VersionInfo {
 }
 export declare function releaseUrlFrom(info: VersionInfo | null | undefined): string;
 export declare function getVersionInfo(checkRemote?: boolean): Promise<VersionInfo>;
+export type UpdateChannel = "stable" | "beta";
+export interface UpdateChannelState {
+    channel: UpdateChannel;
+    /** The admin's choice; a beta build reports beta whatever it is. */
+    stored: UpdateChannel;
+    runningBeta: boolean;
+}
+export declare function getUpdateChannel(): Promise<UpdateChannelState>;
+export declare function setUpdateChannel(channel: UpdateChannel): Promise<UpdateChannelState>;
+export interface ReleaseInfo {
+    version: string;
+    tagName: string;
+    name: string;
+    url: string;
+    publishedAt: string;
+    prerelease: boolean;
+    notes: string;
+}
+export declare function getChannelReleases(): Promise<{
+    localVersion: string | null;
+    stable: ReleaseInfo | null;
+    beta: ReleaseInfo | null;
+}>;
 export declare function getDatabaseHealth(): Promise<Record<string, unknown>>;

package/dist/host/types/src/ui/components/connection/ConnectionLogPanel.d.ts

@@ -2,8 +2,9 @@ interface ConnectionLogPanelProps {
     isConnecting: boolean;
     isConnected: boolean;
     hasConnectionError: boolean;
+    /** Kept for older callers. The log always sits at the bottom. */
     position?: "top" | "bottom";
     className?: string;
 }
-export declare function ConnectionLogPanel({ isConnecting, isConnected, hasConnectionError, position, className, }: ConnectionLogPanelProps): import("react").JSX.Element;
+export declare function ConnectionLogPanel({ isConnecting, isConnected, hasConnectionError, className, }: ConnectionLogPanelProps): import("react").JSX.Element;
 export {};

package/dist/host/types/src/ui/components/connection/ConnectionScreen.d.ts

@@ -12,9 +12,7 @@ export interface ConnectionScreenProps {
     message?: string;
     /** Second line under the headline, usually user@host:port. */
     detail?: string;
-    /** Headline once it has failed and is not retrying on its own. */
-    errorMessage?: string;
-    /** The reason it failed, shown under the headline. */
+    /** The reason it failed. Falls back to the last error in the log. */
     errorDetail?: string | null;
     /** Shown instead of a failure when the feature cannot run here. */
     unavailable?: ConnectionUnavailable | null;
@@ -23,12 +21,14 @@ export interface ConnectionScreenProps {
     maxAttempts?: number;
     nextRetryInMs?: number | null;
     onManualRetry?: () => void;
-    retryLabel?: string;
+    /** Headline when it was up and dropped. */
     disconnectedMessage?: string;
+    /** Overrides closing the tab this sits in. False hides the button. */
+    onClose?: (() => void) | false;
     extraActions?: React.ReactNode;
     logPosition?: "top" | "bottom";
     emptyState?: React.ReactNode;
     className?: string;
 }
 /** The one screen every connection shows until it is up. */
-export declare function ConnectionScreen({ status, message, detail, errorMessage, errorDetail, unavailable, backgroundColor, attempt, maxAttempts, nextRetryInMs, onManualRetry, retryLabel, disconnectedMessage, extraActions, logPosition, emptyState, className, }: ConnectionScreenProps): React.JSX.Element;
+export declare function ConnectionScreen({ status, message, detail, errorDetail, unavailable, backgroundColor, attempt, maxAttempts, nextRetryInMs, onManualRetry, disconnectedMessage, onClose, extraActions, logPosition, emptyState, className, }: ConnectionScreenProps): React.JSX.Element;