@termix-ssh/plugin-sdk 1.0.11 → 1.0.12

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

@@ -0,0 +1,42 @@
+import type { HostDefaultsLevel, ResolvedHostDefault } from "../../types/host-defaults";
+export interface HostDefaultsLevelData {
+    /** Values set at this level, by "namespace.key". */
+    values: Record<string, unknown>;
+    /** What each key reads when this level leaves it unset. */
+    inherited: Record<string, ResolvedHostDefault>;
+}
+export interface HostDefaultsTarget {
+    level: HostDefaultsLevel;
+    folderId?: number;
+}
+export interface HostDefaultsChange {
+    set: Record<string, unknown>;
+    unset: string[];
+}
+export declare function getHostDefaultsLevel(target: HostDefaultsTarget): Promise<HostDefaultsLevelData>;
+export declare function saveHostDefaultsLevel(target: HostDefaultsTarget, change: HostDefaultsChange): Promise<{
+    changedHosts?: number;
+    jobId?: string;
+}>;
+export declare function previewHostDefaultsLevel(target: HostDefaultsTarget, change: HostDefaultsChange): Promise<{
+    changedHosts: number;
+}>;
+export declare function getHostDefaultsJob(id: string): Promise<{
+    status: "running" | "done" | "failed";
+    changedHosts: number;
+}>;
+/** A folder's id for its defaults, created when it only exists on hosts. */
+export declare function getFolderDefaultsId(name: string): Promise<number>;
+/** What a host, or a new one in a folder or under a parent, resolves to. */
+export declare function resolveHostDefaults(where: {
+    hostId?: number;
+    folder?: string | null;
+    parentHostId?: number | null;
+}, adminTargetUserId?: string): Promise<Record<string, ResolvedHostDefault>>;
+export declare function resetHostToDefaults(hostIds: number[], reset: {
+    all?: boolean;
+    namespaces?: string[];
+    keys?: string[];
+}): Promise<void>;
+/** Waits for a server-wide defaults job. Resolves to the hosts it changed, or null. */
+export declare function waitForDefaultsJob(id: string, intervalMs?: number, maxWaitMs?: number): Promise<number | null>;

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

@@ -0,0 +1,2 @@
+export declare function getHostTags(): Promise<string[]>;
+export declare function saveHostTags(tags: string[]): Promise<string[]>;

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

@@ -0,0 +1,40 @@
+/** A layout or theme plugin the server found but could not load. */
+export interface UnavailableLook {
+    id: string;
+    version: string | null;
+    layouts: string[];
+    themes: string[];
+    error: string;
+}
+/** Everything the browser picks the layout and theme from. */
+export interface LookResponse {
+    layoutId: string | null;
+    themeId: string | null;
+    /** Admin defaults. */
+    defaults: {
+        layout: string | null;
+        theme: string | null;
+    };
+    /** The default-look plugin's layout and theme. */
+    defaultLook: {
+        layout: string | null;
+        theme: string | null;
+    };
+    /** TERMIX_SAFE_LAYOUT is set on the server. */
+    safeLayout: boolean;
+    unavailable: UnavailableLook[];
+}
+export declare function getLook(): Promise<LookResponse>;
+/** The user's own layout and theme; null follows the default. */
+export declare function saveUserLook(look: {
+    layoutId?: string | null;
+    themeId?: string | null;
+}): Promise<void>;
+/** Admin only. Null clears a default. */
+export declare function saveDefaultLook(defaults: {
+    layout?: string | null;
+    theme?: string | null;
+}): Promise<{
+    layout: string | null;
+    theme: string | null;
+}>;

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

@@ -62,6 +62,10 @@ export interface UserPreferences {
     compactHostView?: boolean | null;
     statusColorScheme?: string | null;
     customKeybindings?: string | null;
+    /** Layout this user chose; null follows the admin default. */
+    layoutId?: string | null;
+    /** Theme this user chose; null follows the admin default. */
+    themeId?: string | null;
 }
 export declare function parseCustomKeybindings(raw?: string | null): CustomKeybinding[];
 /**

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

@@ -56,6 +56,24 @@ export interface PluginViewContribution {
     titleKey: string;
     icon?: string;
 }
+export interface PluginLayoutContribution {
+    id: string;
+    label: string;
+    description?: string;
+    defaultTheme?: string;
+    default?: boolean;
+}
+export interface PluginThemeContribution {
+    id: string;
+    label: string;
+    mode: "light" | "dark";
+    css: string;
+    swatch?: {
+        background: string;
+        panel: string;
+        text: string;
+    };
+}
 export interface PluginContributions {
     tabs?: PluginTabContribution[];
     panels?: PluginViewContribution[];
@@ -69,6 +87,8 @@ export interface PluginContributions {
         descriptionKey: string;
     }[];
     uiPresets?: PluginUiPresets;
+    layouts?: PluginLayoutContribution[];
+    themes?: PluginThemeContribution[];
 }
 export { isRedactedSecret, type RedactedSecret, } from "@termix-ssh/plugin-sdk/settings";
 export type PluginSettingsValues = Record<string, unknown>;
@@ -117,6 +137,10 @@ export interface PluginSummary {
     assetVersion?: string | null;
     /** "en" plus the xx_YY names of shipped translations. */
     locales?: string[];
+    /** Cache key for the theme CSS files; null without themes. */
+    themeVersion?: string | null;
+    /** The app is drawn with this plugin by default; it cannot be uninstalled. */
+    defaultLook?: boolean;
     tier?: string;
     source?: string;
     /** Capabilities this plugin's manifest declares. Admins only. */
@@ -317,6 +341,8 @@ export declare function setRegistryEnabled(id: string, enabled: boolean): Promis
 export declare function removeRegistry(id: string): Promise<void>;
 export declare function updateAllPlugins(): Promise<UpdateAllResult>;
 export declare function uninstallPlugin(pluginId: string): Promise<void>;
+/** Puts a bundled plugin back to the copy that shipped with this install. */
+export declare function restoreBundledPlugin(pluginId: string): Promise<void>;
 export declare function previewPluginState(pluginId: string, enabled: boolean): Promise<PluginStateChange>;
 export declare function setPluginState(pluginId: string, enabled: boolean, consent?: {
     version: string;

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

@@ -0,0 +1,6 @@
+/**
+ * Admin allowlists of private addresses that outbound requests may reach, one
+ * per core feature that makes them.
+ */
+export declare function getNotificationPrivateEndpoints(): Promise<string[]>;
+export declare function setNotificationPrivateEndpoints(hosts: string[]): Promise<string[]>;

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

@@ -0,0 +1,25 @@
+export type TlsCertificateInfo = {
+    subject: string;
+    issuer: string;
+    names: string[];
+    notBefore: string;
+    notAfter: string;
+    selfSigned: boolean;
+    fingerprint: string;
+};
+export type TlsStatus = {
+    enabled: boolean;
+    certificate: TlsCertificateInfo | null;
+    renewal: {
+        pluginId: string;
+        pluginName: string;
+    } | null;
+};
+export declare function getTlsStatus(): Promise<TlsStatus>;
+export declare function uploadTlsCertificate(payload: {
+    certificate: string;
+    privateKey: string;
+}): Promise<TlsStatus & {
+    success: boolean;
+    reloadMessage?: string;
+}>;

package/dist/host/types/src/ui/auth/ElectronLoginForm.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface ElectronLoginFormProps {
+    serverUrl: string;
+    onAuthSuccess: (token: string | null) => void | Promise<void>;
+    onChangeServer: () => void;
+    targetPurpose?: "local" | "link";
+}
+export declare function ElectronLoginForm({ serverUrl, onAuthSuccess, onChangeServer, targetPurpose, }: ElectronLoginFormProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,78 @@
+import * as React from "react";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "heading" | "value"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { Command, CommandInput, CommandList, CommandGroup, CommandItem, CommandSeparator, CommandEmpty, CommandShortcut, };

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

@@ -0,0 +1,16 @@
+export declare const DEFAULT_FOLDER_ICON = "folder";
+export declare const DEFAULT_FOLDER_COLOR = "#f59145";
+export declare function FolderIconEl({ icon, className, style, }: {
+    icon?: string | null;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react").JSX.Element;
+export declare function HexColorPicker({ value, onChange, }: {
+    value: string;
+    onChange: (hex: string) => void;
+}): import("react").JSX.Element;
+export declare function IconPicker({ value, color, onChange, }: {
+    value: string;
+    color?: string;
+    onChange: (icon: string) => void;
+}): import("react").JSX.Element;

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

@@ -6,7 +6,8 @@ type ThemeProviderProps = {
 };
 type ThemeProviderState = {
     theme: ThemeId;
-    setTheme: (theme: ThemeId) => void;
+    /** Pass persist false to show a theme without keeping it in this browser. */
+    setTheme: (theme: ThemeId, persist?: boolean) => void;
     setThemePreview: (theme: ThemeId | null) => void;
 };
 export declare function ThemeProvider({ children, defaultTheme, storageKey, ...props }: ThemeProviderProps): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+interface VersionBadgeProps {
+    status: "up_to_date" | "requires_update" | "beta" | "unknown";
+    releaseUrl?: string;
+    className?: string;
+}
+export declare function VersionBadge({ status, releaseUrl, className, }: VersionBadgeProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/hooks/use-page-visible-interval.d.ts

@@ -0,0 +1,10 @@
+type Options = {
+    /** Run callback once when the effect mounts (if visible). Default true. */
+    runOnMount?: boolean;
+};
+/**
+ * Runs `callback` on `intervalMs` while the page is visible.
+ * Pauses when the tab is backgrounded; fires once on resume.
+ */
+export declare function usePageVisibleInterval(callback: () => void, intervalMs: number, enabled?: boolean, options?: Options): void;
+export {};

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

@@ -0,0 +1,15 @@
+import type { ComponentType } from "react";
+export interface ActivityTarget {
+    icon: ComponentType<{
+        className?: string;
+    }> | undefined;
+    /** Tab type the entry reopens. */
+    tab: string;
+    labelKey: string | undefined;
+}
+/**
+ * What a recent-activity entry opens and how it is labelled. Plugin tabs
+ * claim their activity types through the registry, so an entry whose plugin
+ * is gone simply has no target.
+ */
+export declare function activityTarget(type: string): ActivityTarget | undefined;

package/dist/host/types/src/ui/lib/app-version.d.ts

@@ -0,0 +1,2 @@
+/** The version of this build, empty in a dev build. */
+export declare const APP_VERSION: string | undefined;

package/dist/host/types/src/ui/lib/apply-ui-preset.d.ts

@@ -0,0 +1,19 @@
+import { type UiPreset, type UiRailPreferences } from "../../types/ui-preferences";
+import { type RailItemDef } from "../sidebar/rail-items";
+export declare function buildDashboardSlots(cardIds: string[]): {
+    key: string;
+    id: string;
+    panel: "main" | "side";
+    order: number;
+    height: number;
+}[];
+/**
+ * The rail views a preset hides: its own list, plus every plugin item that
+ * does not ask to stay when the preset hides plugin items.
+ */
+export declare function presetHiddenRailTabs(rail: UiRailPreferences, pluginItems: Pick<RailItemDef, "id" | "simplePreset" | "hideable">[]): string[];
+/**
+ * Writes a preset's values into the stores that own them. Safe to call when
+ * nothing changed; every write is idempotent.
+ */
+export declare function applyPresetSideEffects(preset: Exclude<UiPreset, "custom">): Promise<void>;

package/dist/host/types/src/ui/lib/create-id.d.ts

@@ -0,0 +1,2 @@
+/** A random id, with a fallback for insecure contexts that lack randomUUID. */
+export declare function createId(): string;

package/dist/host/types/src/ui/lib/database-transfer-url.d.ts

@@ -0,0 +1,8 @@
+type BrowserLocation = Pick<Location, "protocol" | "host" | "hostname" | "port">;
+interface DatabaseTransferUrlOptions {
+    electron: boolean;
+    configuredServerUrl?: string | null;
+    location: BrowserLocation;
+}
+export declare function getDatabaseTransferUrl(operation: "export" | "import", { electron, configuredServerUrl, location }: DatabaseTransferUrlOptions): string;
+export {};

package/dist/host/types/src/ui/lib/desktop-updates.d.ts

@@ -0,0 +1,29 @@
+export type DesktopUpdateMode = "automatic" | "prompt" | "never";
+export type DesktopInstallKind = "auto" | "manual" | "store" | "disabled";
+export type DesktopUpdateStatus = "idle" | "checking" | "available" | "downloading" | "downloaded" | "up-to-date" | "error";
+export interface DesktopUpdateState {
+    kind: DesktopInstallKind;
+    mode: DesktopUpdateMode;
+    currentVersion: string;
+    status: DesktopUpdateStatus;
+    version: string | null;
+    releaseUrl: string | null;
+    progress: number | null;
+    error: string | null;
+}
+interface DesktopUpdatesBridge {
+    getState: () => Promise<DesktopUpdateState | null>;
+    check: () => Promise<DesktopUpdateState | null>;
+    download: () => Promise<DesktopUpdateState | null>;
+    install: () => Promise<boolean>;
+    setMode: (mode: DesktopUpdateMode) => Promise<DesktopUpdateState | null>;
+    onState: (callback: (state: DesktopUpdateState) => void) => () => void;
+}
+/** The main process updater, or null in the browser and on older builds. */
+export declare function desktopUpdates(): DesktopUpdatesBridge | null;
+/** Whether this install has an updater the user can configure. */
+export declare function canConfigureUpdates(state: DesktopUpdateState | null): state is DesktopUpdateState;
+/** Which toast, if any, this state calls for. */
+export declare function updateToastFor(state: DesktopUpdateState | null): "prompt" | "manual" | "ready" | null;
+export declare function useDesktopUpdate(): DesktopUpdateState | null;
+export {};

package/dist/host/types/src/ui/lib/host-connection-tabs.d.ts

@@ -0,0 +1,14 @@
+import type { Host, TabType } from "../../types/ui-types";
+/**
+ * Which tab a click on a host opens. The ways to connect (the SSH terminal,
+ * remote desktop) are host actions that plugins register, so the answer is the
+ * highest-priority connect action the host allows, or null when no running
+ * plugin can connect to it.
+ */
+export declare function getDefaultConnectionTab(host: Host): TabType | null;
+/**
+ * The preferred tab if the host allows it. A connect tab type the host has
+ * switched off falls back to the host's default; any other type is taken as
+ * asked.
+ */
+export declare function resolveHostTabType(host: Host, preferredType?: TabType): TabType | null;

package/dist/host/types/src/ui/lib/host-to-ssh-host.d.ts

@@ -0,0 +1,4 @@
+import type { Host } from "../../types/ui-types";
+import type { SSHHost } from "../../types";
+/** The shell's Host in the SSHHost shape the connection surfaces take. */
+export declare function hostToSSHHost(h: Host): SSHHost;

package/dist/host/types/src/ui/lib/issue-url.d.ts

@@ -0,0 +1,21 @@
+export declare const CORE_REPO_URL = "https://github.com/Termix-SSH/Termix";
+/** A GitHub repo URL without .git or a trailing slash, or null if it is not one. */
+export declare function normalizeGitHubRepo(repository?: string | null): string | null;
+/**
+ * A new issue from one of the repo's issue forms, with fields prefilled by
+ * their form ids. Logs get cut first when the URL would be too long.
+ */
+export declare function buildIssueUrl(repo: string, options: {
+    template: string;
+    title?: string;
+    fields?: Record<string, string | null | undefined>;
+}): string;
+/** One line on where Termix is running, for the environment field. */
+export declare function describeEnvironment(userAgent?: string, desktop?: boolean): string;
+/** A bug report on the Termix core repo. */
+export declare function reportCoreIssueUrl(termixVersion?: string): string;
+/** Beta feedback on the core repo, listing every plugin running a beta. */
+export declare function reportBetaFeedbackUrl(termixVersion?: string, betaPlugins?: Array<{
+    id: string;
+    version: string;
+}>): string;

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

@@ -0,0 +1,9 @@
+import type { TabType } from "../../types/ui-types";
+export declare const LOCAL_ADAPTIVE_PREFERENCES_KEY = "termix.local.adaptive-engine.v1";
+/** Records an abstract action locally. Callers must not use raw paths or input. */
+export declare function recordLocalPreference(scope: string, action: string, now?: number): void;
+/** Returns a learned action only after enough consistent local evidence. */
+export declare function getLocalPreference<T extends string>(scope: string, candidates: readonly T[], fallback: T, now?: number): T;
+export declare function clearLocalAdaptivePreferences(): void;
+export declare function recordHostActionPreference(hostId: string, action: TabType): void;
+export declare function getPreferredHostAction(hostId: string, candidates: readonly TabType[], fallback: TabType): TabType;

package/dist/host/types/src/ui/lib/pane-nav-hotkey.d.ts

@@ -0,0 +1,7 @@
+export type PaneNavDirection = "left" | "right" | "up" | "down";
+/**
+ * The split pane to move to for this key, if any. Cmd+Option+Arrow on macOS,
+ * where Option+Arrow moves the shell cursor by word, Alt+Arrow elsewhere.
+ */
+export declare function getPaneNavDirection(e: KeyboardEvent): PaneNavDirection | null;
+export declare function paneNavHotkeyLabel(): string;

package/dist/host/types/src/ui/lib/plugin-i18n.d.ts

@@ -1,4 +1,5 @@
-import type { TFunction } from "i18next";
+/** The part of a translate function these helpers use. */
+export type Translator = (key: string, options?: Record<string, unknown>) => string;
 /**
  * Where a plugin's i18n keys resolve from.
  *
@@ -15,12 +16,12 @@ export declare function pluginKey(pluginId: string, key: string | undefined): st
  * else the manifest's. A plugin whose strings are not loaded, like one only
  * listed in a registry, shows the manifest name.
  */
-export declare function pluginName(t: TFunction, plugin: {
+export declare function pluginName(t: Translator, plugin: {
     id: string;
     name: string;
 }): string;
 /** Same as pluginName, for "plugin.description". */
-export declare function pluginDescription(t: TFunction, plugin: {
+export declare function pluginDescription(t: Translator, plugin: {
     id: string;
     description?: string | null;
 }): string;

package/dist/host/types/src/ui/lib/role-label.d.ts

@@ -0,0 +1,3 @@
+import type { Translator } from "./plugin-i18n";
+/** System roles store an i18n key as their display name. */
+export declare function roleLabel<T extends string | null | undefined>(t: Translator, displayName: T): T | string;

package/dist/host/types/src/ui/look/LookSettings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The layout picker, plus the default layout and theme for everyone when an
+ * admin is looking. Lists what the layout and theme registries hold, so
+ * plugin layouts and themes show up as soon as they are installed.
+ */
+export declare function LookSettings({ isAdmin }: {
+    isAdmin: boolean;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/look/layout-registry.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentType } from "react";
+import type { TFunction } from "i18next";
+/** A layout someone can choose, known from a manifest before its code loads. */
+export interface LayoutDescriptor {
+    id: string;
+    /** i18n key in the plugin namespace, or plain text. */
+    label: string;
+    description?: string;
+    defaultTheme?: string;
+    /** Set for a plugin layout. */
+    pluginId?: string;
+}
+/** A layout whose code is running, from app.registerLayout. */
+export interface RegisteredLayout {
+    id: string;
+    pluginId?: string;
+    component: ComponentType;
+    /** Shown on phones and narrow windows. Never in the desktop app. */
+    mobileComponent?: ComponentType;
+    defaultTheme?: string;
+}
+export declare const registerLayout: (item: RegisteredLayout) => () => void;
+export declare const getRegisteredLayout: (id: string) => RegisteredLayout;
+export declare const useRegisteredLayouts: () => RegisteredLayout[];
+export declare const resetRegisteredLayouts: () => void;
+/** Every layout that can be chosen, from the installed plugins. */
+export declare function listLayouts(): LayoutDescriptor[];
+export declare function getLayoutDescriptor(id: string): LayoutDescriptor | undefined;
+/** Replaces the plugin layouts at once, from the plugin list. */
+export declare function setPluginLayouts(layouts: LayoutDescriptor[]): void;
+export declare function useLayouts(): LayoutDescriptor[];
+export declare function layoutLabel(layout: LayoutDescriptor, t: TFunction): string;
+/** Test seam. */
+export declare function resetPluginLayouts(): void;

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

@@ -0,0 +1,29 @@
+import { type LookResponse } from "../api/look-api";
+interface LookState {
+    /** The server answered, or failed to; the look is decided either way. */
+    loaded: boolean;
+    response: LookResponse | null;
+}
+/** Fetches the look once per session. Never rejects: no answer means defaults. */
+export declare function loadLook(): Promise<LookResponse | null>;
+/** Fetches again, e.g. after an admin changed the defaults. */
+export declare function reloadLook(): Promise<LookResponse | null>;
+/** On logout: the next user has their own look. */
+export declare function resetLook(): void;
+export declare function getLookState(): LookState;
+export declare function subscribeLook(listener: () => void): () => void;
+export declare function useLookState(): LookState;
+/** The layout to show now. Remembered so a failed fetch next time still knows. */
+export declare function chosenLayoutId(): string;
+/** The URL or the server asks for the repair view. */
+export declare function safeLayoutRequested(): boolean;
+/** The user's own layout; null goes back to the default. */
+export declare function chooseLayout(layoutId: string | null): Promise<void>;
+/** The user's own theme; null goes back to the default. */
+export declare function chooseThemeForAccount(themeId: string | null): Promise<void>;
+/** Admin only: what everyone sees until they choose their own. */
+export declare function chooseDefaultLook(defaults: {
+    layout?: string | null;
+    theme?: string | null;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,18 @@
+import type { LookResponse } from "../api/look-api";
+/** The theme a fresh install starts in when nothing else says otherwise. */
+export declare const FALLBACK_THEME = "dark";
+/**
+ * The layout to show: the user's choice, else the admin default, else the
+ * default look. Empty when none of them names one, which the repair view
+ * answers. Without an answer from the server the last layout this browser
+ * showed stands in.
+ */
+export declare function resolveLayoutId(look: LookResponse | null, lastShown?: string | null): string;
+/**
+ * The theme to show: the user's choice, else the one this browser kept
+ * (today's per-device setting, so existing users see no change), else the
+ * admin default, else the layout's own, else the default look's.
+ */
+export declare function resolveThemeId(look: LookResponse | null, localTheme: string | null, layoutDefaultTheme?: string): string;
+/** ?safe-layout=1 in the address bar opens the repair view. */
+export declare function safeLayoutInUrl(search: string): boolean;

package/dist/host/types/src/ui/look/theme-css.d.ts

@@ -0,0 +1,7 @@
+import { type ThemeDef } from "./theme-registry";
+/**
+ * Loads the one plugin theme stylesheet the shown theme needs, and only that
+ * one. Built-in themes need none. A theme whose plugin has not loaded yet
+ * keeps the stylesheet it had last time.
+ */
+export declare function applyThemeCss(id: string, theme: ThemeDef | undefined): void;