@rahdar/plugin-sdk 0.0.0-stage → 2026.10.50

package/types/kernel/inbox/InboxView.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The signed-in user's inbox: every notice Rahdar and its plugins posted to them that is still kept, newest
+ * first, a page at a time. Unread or all is in the URL (`?filter=unread`), so the view can be shared and
+ * restored. Opening a notice marks it read; dismissing one deletes it.
+ */
+export declare function InboxView(): import("react").JSX.Element;

package/types/kernel/inbox/NoticeRow.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+import { type InboxItem } from './api.ts';
+/**
+ * One notice, in the header's popover and on the inbox page: its severity, whether it is unread, its title
+ * (a link when it has one), the body on the page, and when it arrived. Opening it marks it read.
+ *
+ * <p>The severity and the unread state are in words for assistive technology; the icon and the dot repeat
+ * them. A warning or critical notice is the only one with colour.
+ */
+export declare function NoticeRow({ item, now, onOpen, showBody, actions, }: Readonly<{
+    item: InboxItem;
+    now: number;
+    /** Called when the notice is opened: followed, or for one without a link, activated. */
+    onOpen: (item: InboxItem) => void;
+    showBody?: boolean;
+    actions?: ReactNode;
+}>): import("react").JSX.Element;

package/types/kernel/inbox/api.d.ts

@@ -0,0 +1,53 @@
+import type { components } from '../api/schema.d.ts';
+type Schemas = components['schemas'];
+export type InboxItem = Schemas['ItemView'];
+export type InboxPage = Schemas['PageView'];
+export type InboxCount = Schemas['CountView'];
+export type InboxSeverity = InboxItem['severity'];
+/** Which notices a list shows: only the unread ones, or every one still kept. */
+export type InboxFilter = 'unread' | 'all';
+/** Every inbox query key starts from `inboxKeys.all`, so one invalidation (a stream signal) reaches all of them. */
+export declare const inboxKeys: {
+    all: readonly ["inbox"];
+    count: readonly ["inbox", "count"];
+    latest: readonly ["inbox", "latest"];
+    list: (filter: InboxFilter) => readonly ["inbox", "list", InboxFilter];
+};
+/** The count as the badge shows it: "99+" once the server stops counting. */
+export declare function unreadLabel(count: InboxCount | undefined): string;
+/**
+ * Whether a notice's link is a path inside Rahdar. The server refuses any other on posting; this is the
+ * second check, so a notice can never send the operator to another site.
+ */
+export declare function isInAppPath(link: string | null | undefined): link is string;
+/** How many notices the header's popover shows. */
+export declare const LATEST_LIMIT = 10;
+/**
+ * The unread count the bell shows. While the user stream is `live` it keeps the count current and nothing
+ * polls; while it is not, the count is asked for every minute, so a lost connection never freezes it.
+ */
+export declare function useInboxCount(live: boolean): import("@tanstack/react-query").UseQueryResult<{
+    unread: number;
+    capped: boolean;
+}, Error>;
+/** The newest notices, read or not, for the header's popover. Fetched only while the popover is open. */
+export declare function useLatestNotices(enabled: boolean): import("@tanstack/react-query").UseQueryResult<{
+    items: components["schemas"]["ItemView"][];
+    next?: number | null;
+}, Error>;
+/** The inbox page's list, newest first, a page at a time by keyset (`before` the last id shown). */
+export declare function useInboxList(filter: InboxFilter): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/query-core").InfiniteData<{
+    items: components["schemas"]["ItemView"][];
+    next?: number | null;
+}, unknown>, Error>;
+/** Marks the given notices read, or with `upTo` every notice up to that id (what "Mark all read" sends). */
+export declare function useMarkRead(): import("@tanstack/react-query").UseMutationResult<{
+    updated: number;
+}, Error, {
+    ids: number[];
+} | {
+    upTo: number;
+}, unknown>;
+/** Dismisses one notice: it is deleted, not just read. */
+export declare function useDismissNotice(): import("@tanstack/react-query").UseMutationResult<void, Error, number, unknown>;
+export {};

package/types/kernel/keyboard/ShortcutsHelp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Every keyboard shortcut, in one place (ADR-0109), with the switch that turns the single-key ones
+ * off: a header button and the popover it opens, like the refresh control beside it. `?` opens the
+ * same popover; the button keeps it reachable when the single-key shortcuts are off.
+ */
+export declare function ShortcutsHelp(): import("react").JSX.Element;

package/types/kernel/keyboard/filterShortcut.d.ts

@@ -0,0 +1,5 @@
+import { type RefObject } from 'react';
+/** Registers a view's filter field for `/` while the view is mounted. */
+export declare function useFilterShortcut(ref: RefObject<HTMLInputElement | null>): void;
+/** Focuses the registered filter field; false when the view has none, so the key is left alone. */
+export declare function focusFilter(): boolean;

package/types/kernel/keyboard/keys.d.ts

@@ -0,0 +1,14 @@
+/** A modified shortcut as this platform names it: `⌘K` on a Mac, `Ctrl+K` everywhere else. */
+export declare function modShortcut(key: string): string;
+/**
+ * The printable key an event stands for, in the Latin layout the shortcuts are named in. On a
+ * non-Latin layout (Persian, Russian, Greek) `event.key` is that script's letter, so the physical
+ * key decides instead: an operator does not switch layout to press `g q`.
+ */
+export declare function latinKey(event: KeyboardEvent): string;
+/**
+ * Whether a key press belongs to something else and must not be taken as a shortcut (ADR-0109):
+ * typing into a field or an editor, a modified key, an IME composition, a key already handled, and
+ * anything inside a dialog or a menu — a confirmation is never navigated away from by a stray key.
+ */
+export declare function ignoredForShortcuts(event: KeyboardEvent): boolean;

package/types/kernel/keyboard/shortcuts.d.ts

@@ -0,0 +1,5 @@
+export declare function singleKeyShortcutsEnabled(): boolean;
+export declare function setSingleKeyShortcuts(next: boolean): void;
+export declare function useSingleKeyShortcuts(): [boolean, (next: boolean) => void];
+export declare function setShortcutsHelpOpen(next: boolean): void;
+export declare function useShortcutsHelpOpen(): boolean;

package/types/kernel/keyboard/useKeySequences.d.ts

@@ -0,0 +1,16 @@
+import { type NavContribution } from '../feature.ts';
+/**
+ * The views that have a `g` letter: built-in views only — a plugin's letter is ignored, so a plugin
+ * can never take a letter an operator already relies on (ADR-0109).
+ */
+export declare function viewHotkeys(features: {
+    id: string;
+    nav?: NavContribution[];
+}[]): Map<string, NavContribution>;
+/**
+ * The single-key shortcuts (ADR-0109), as one document listener mounted by the shell:
+ * `g` then a view's letter goes to that view of the open cluster, `?` opens the list of shortcuts,
+ * and `/` focuses the view's filter when it has one. All of them are off when the operator turned
+ * single-key shortcuts off, and ignored while typing, with a modifier, and inside dialogs and menus.
+ */
+export declare function useKeySequences(): void;

package/types/kernel/manifest.d.ts

@@ -0,0 +1,21 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import { type ApiError } from './api/request.ts';
+import type { components } from './api/schema.d.ts';
+import type { ModuleId, RahdarFeature } from './feature.ts';
+export type ManifestView = components['schemas']['ManifestView'];
+export type ManifestFeatureView = components['schemas']['ManifestFeatureView'];
+export declare const manifestKey: readonly ["manifest"];
+/**
+ * What this installation offers (feature-modules spec). It describes and never authorizes: every
+ * endpoint enforces its permission whatever a screen derived from this. Read once per page load:
+ * plugin bundles are loaded before the router exists, so a plugin change needs a reload anyway,
+ * and `usePluginsChanged` offers one when the server's `version` moves on.
+ */
+export declare function useManifest(): UseQueryResult<ManifestView, ApiError>;
+/** The manifest's entry for a module; undefined until the manifest has loaded. */
+export declare function useManifestFeature(id: ModuleId): ManifestFeatureView | undefined;
+/**
+ * The given features less those this installation has disabled. Until the manifest answers, every
+ * feature counts as enabled: hiding a view before then would state something nobody has checked.
+ */
+export declare function useEnabledFeatures(features: RahdarFeature[]): RahdarFeature[];

package/types/kernel/metrics/ChartPanel.d.ts

@@ -0,0 +1,28 @@
+import type { ApiError } from '../api/request.ts';
+/** Every metric plot is this tall, whatever it is currently able to show. */
+export declare const CHART_HEIGHT = "13.75rem";
+/**
+ * A titled panel around one metric plot, and the three states it can be in.
+ *
+ * Failure, emptiness and loading are rendered as three different things at one
+ * fixed height (ADR-0055). Both halves of that matter:
+ *
+ * - a metrics read that returned 500 used to render "No samples in this window
+ *   yet", which presents an outage as a fact about the cluster — and a flat empty
+ *   chart during an incident reads as "quiet", the most expensive possible
+ *   misreading;
+ * - a panel that collapses while loading and expands when data arrives moves the
+ *   page under a pointer already travelling towards something else.
+ */
+export declare function ChartPanel({ title, unit, isPending, error, isEmpty, emptyLabel, note, children, }: Readonly<{
+    title: string;
+    unit: string;
+    isPending: boolean;
+    error: ApiError | null;
+    /** True when the read succeeded and carried nothing for this window. */
+    isEmpty: boolean;
+    emptyLabel: string;
+    /** A coverage caveat that belongs beside the title, not inside a tooltip. */
+    note?: React.ReactNode;
+    children: React.ReactNode;
+}>): import("react").JSX.Element;

package/types/kernel/metrics/MetricChart.d.ts

@@ -0,0 +1,13 @@
+import type { MetricRange } from '../time/ranges.ts';
+/**
+ * Rahdar's time-proportional chart of one plugin metric for one subject (ADR-0055, ADR-0113):
+ * a titled panel that tells loading, failure and an empty window apart, over a live range.
+ */
+export declare function MetricChart({ clusterId, metric, subject, title, range, emptyLabel, }: Readonly<{
+    clusterId: string;
+    metric: string;
+    subject: string;
+    title: string;
+    range?: MetricRange;
+    emptyLabel?: string;
+}>): import("react").JSX.Element;

package/types/kernel/metrics/axis.d.ts

@@ -0,0 +1,71 @@
+import type { components } from '../api/schema.d.ts';
+import { type MetricRange } from '../time/ranges.ts';
+type MetricSeries = components['schemas']['MetricSeries'];
+/**
+ * Format an instant in the operator's chosen zone.
+ *
+ * Bare `dayjs(ms).format(...)` renders in the browser's zone, which used to leave
+ * the charts and the tables disagreeing on every deployment where the two differed
+ * — the axis in local time, every table in UTC, and nothing saying so. Everything
+ * that renders a metric timestamp goes through here.
+ */
+export declare function formatInZone(ms: number, pattern: string): string;
+export declare function tickFormatter(range: MetricRange): (ms: number) => string;
+export declare function labelFormatter(range: MetricRange): (ms: number) => string;
+/**
+ * Props for the recharts `XAxis` behind every metric chart.
+ *
+ * `type: 'number'` with `scale: 'time'` is the whole decision. The explicit
+ * `[from, to]` domain — rather than `['dataMin', 'dataMax']` — keeps the plotted
+ * width equal to the *requested* window, so a series that stops halfway through
+ * the range renders as a chart that is half empty rather than one that silently
+ * rescales to whatever data survived.
+ */
+export declare function timeAxisProps(range: MetricRange, from: number, to: number): {
+    type: "number";
+    scale: "time";
+    domain: [number, number];
+    tickFormatter: (ms: number) => string;
+    minTickGap: number;
+    stroke: string;
+};
+/**
+ * `integral` is for a metric that only ever takes whole values — a consumer
+ * count. Without it recharts picks fractional ticks for a small domain, and the
+ * integer formatter renders every one of them as the same "0": an axis of five
+ * identical labels beside bars of visibly different heights.
+ */
+export declare function yAxisProps(options?: {
+    integral?: boolean;
+}): {
+    allowDecimals?: boolean | undefined;
+    stroke: string;
+    width: number;
+};
+export declare function gridProps(): {
+    stroke: string;
+};
+/** Bucket boundaries a series is expected to cover, used to size the empty case. */
+export declare function bucketCount(range: MetricRange): number;
+/**
+ * Merge any number of series onto one row per timestamp, keyed by epoch ms.
+ *
+ * Series are merged by timestamp rather than by index because a metric with no
+ * samples in a bucket is simply omitted from its series, so two series over the
+ * same window can carry different bucket sets. Zipping them by position would
+ * silently pair a value with the wrong instant.
+ */
+export declare function mergeByTimestamp(named: Array<{
+    name: string;
+    series: MetricSeries | undefined;
+    field?: 'value' | 'peak';
+}>): Array<Record<string, number>>;
+/** The last point of a series, or `null` when there is none to state. */
+export declare function latest(series: MetricSeries | undefined): number | null;
+/** The first point of a series, for stating movement across the window. */
+export declare function earliest(series: MetricSeries | undefined): number | null;
+/** Depth runs to millions on a real cluster; an axis tick cannot carry the digits. */
+export declare function formatCount(value: number): string;
+export declare function formatExact(value: number): string;
+export declare function formatRate(value: number): string;
+export {};

package/types/kernel/metrics/pluginSeries.d.ts

@@ -0,0 +1,17 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import { ApiError } from '../api/request.ts';
+import type { components } from '../api/schema.d.ts';
+import { type MetricRange } from '../time/ranges.ts';
+type MetricSeriesResponse = components['schemas']['MetricSeriesResponse'];
+/**
+ * A plugin metric's series for one subject over a live range (ADR-0113). Needs the permission the
+ * plugin declared for the metric; without it the read fails like any cluster read the user may
+ * not make.
+ */
+export declare function usePluginSeries(clusterId: string, metric: string, subject: string, range?: MetricRange): UseQueryResult<MetricSeriesResponse, ApiError> & {
+    window: {
+        from: string;
+        to: string;
+    };
+};
+export {};

package/types/kernel/nav/currentView.d.ts

@@ -0,0 +1,21 @@
+import type { NavContribution, RahdarFeature } from '../feature.ts';
+export interface CurrentView {
+    clusterId: string;
+    /** The navigation entry the address is under, when there is one. */
+    item?: NavContribution;
+    /** Its group's label. */
+    groupLabel?: string;
+}
+/**
+ * Which cluster view an address is under (ADR-0109): the navigation entry whose path is the longest
+ * prefix of the path after `/clusters/<id>/`, so a queue's message browser is under Queues and a
+ * bulk run under Bulk runs. Null outside any cluster.
+ */
+export declare function matchView(pathname: string, features: RahdarFeature[]): CurrentView | null;
+export declare function useCurrentView(): CurrentView | null;
+/**
+ * The address of the same view on another cluster (ADR-0109): an operator comparing two clusters
+ * stays on Queues. The view's search is not carried — its filter and its open resource name things
+ * that may not exist there. Without a current view, the cluster's landing page.
+ */
+export declare function sameViewOn(clusterId: string, view: CurrentView | null): string;

package/types/kernel/nav/groups.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The navigation groups, in the order the rail shows them (ADR-0070). The list is closed:
+ * a feature names one of these for each view it contributes, and adding a group is a
+ * kernel change, which keeps the rail coherent as features are added.
+ */
+export declare const NAV_GROUPS: readonly [{
+    readonly id: "observe";
+    readonly label: "Observe";
+}, {
+    readonly id: "messaging";
+    readonly label: "Messaging";
+}, {
+    readonly id: "resources";
+    readonly label: "Resources";
+}, {
+    readonly id: "configuration";
+    readonly label: "Configuration";
+}, {
+    readonly id: "activity";
+    readonly label: "Activity";
+}];
+export type NavGroupId = (typeof NAV_GROUPS)[number]['id'];

package/types/kernel/plugins/PluginBoundary.d.ts

@@ -0,0 +1,25 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+interface Props {
+    pluginId: string;
+    /** What to render instead: nothing for a badge or a palette source, a sentence for a panel. */
+    quiet?: boolean;
+    children: ReactNode;
+}
+/**
+ * Keeps a plugin's failure to itself (ADR-0100): a plugin component that throws while rendering
+ * is replaced by a sentence naming the plugin — or by nothing, where a sentence would not fit —
+ * and the screen around it keeps working.
+ */
+export declare class PluginBoundary extends Component<Props, {
+    error: unknown;
+}> {
+    state: {
+        error: unknown;
+    };
+    static getDerivedStateFromError(error: unknown): {
+        error: {};
+    };
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/types/kernel/plugins/PluginUnavailable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * What an address under `/p/<id>/` shows when no plugin page answers it (ADR-0100): whether the
+ * plugin is installed at all, and if so the state that keeps its page away — never a blank page
+ * or a bare not-found. Administrators are pointed at the plugin's row.
+ */
+export declare function PluginUnavailable(): import("react").JSX.Element;

package/types/kernel/plugins/boot.d.ts

@@ -0,0 +1,33 @@
+import { type RahdarFeature } from '../feature.ts';
+import type { ManifestFeatureView, ManifestView } from '../manifest.ts';
+/** How long the shell waits for the manifest, and for each plugin bundle, before going on without it. */
+export declare const MANIFEST_TIMEOUT_MS = 5000;
+export declare const REMOTE_TIMEOUT_MS = 10000;
+/** What the page learned while starting: the manifest (when it could be read) and every plugin that did not load. */
+export interface Boot {
+    manifest?: ManifestView;
+    /** Why the manifest could not be read; the built-in screens load regardless. */
+    manifestError?: string;
+    plugins: RahdarFeature[];
+    /** Plugin id → why its screens are not here. */
+    failures: Map<string, string>;
+}
+export declare function bootState(): Boot;
+/** For tests. */
+export declare function setBootState(boot: Boot): void;
+/** The Module Federation container name a plugin's bundle is built with: its id, in snake_case. */
+export declare function remoteName(id: string): string;
+type Federation = Pick<typeof import('@module-federation/runtime'), 'registerRemotes' | 'loadRemote'>;
+/**
+ * Loads every active plugin's bundle, each bounded by {@link REMOTE_TIMEOUT_MS}, and keeps the
+ * ones that pass {@link checkPlugin}. A bundle that fails, is slow or breaks the rules is left
+ * out with its reason; nothing a plugin does here can keep Rahdar's own screens from loading.
+ */
+export declare function loadPlugins(entries: ManifestFeatureView[], federation?: () => Promise<Federation>): Promise<Pick<Boot, 'plugins' | 'failures'>>;
+/**
+ * Everything the page needs before it builds its router: the manifest, then the plugins it names.
+ * The sign-in page asks for neither, because nobody is signed in to be answered; the sign-in that
+ * follows reloads the page, which then boots signed in (`LoginView`).
+ */
+export declare function boot(): Promise<Boot>;
+export {};

package/types/kernel/plugins/guarded.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentType } from 'react';
+/** `Inner` inside a {@link PluginBoundary}, with the same props. */
+export declare function guarded<P extends object>(pluginId: string, Inner: ComponentType<P>, quiet?: boolean): ComponentType<P>;

package/types/kernel/plugins/usePluginsChanged.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Offers a reload once the server's plugins differ from the ones this page started with (ADR-0100):
+ * checked when the window regains focus and every minute. It never reloads on its own — the
+ * operator may be halfway through something — and says so once, until they act.
+ */
+export declare function usePluginsChanged(onChange?: () => void): void;

package/types/kernel/plugins/validate.d.ts

@@ -0,0 +1,19 @@
+import { type RahdarFeature } from '../feature.ts';
+import type { ManifestFeatureView } from '../manifest.ts';
+/** A loaded plugin module, accepted and made safe to mount, or the reason it was not. */
+export type Checked = {
+    ok: true;
+    feature: RahdarFeature;
+} | {
+    ok: false;
+    reason: string;
+};
+/** The first segment a plugin route's path must have: everything it adds lives under `p/<id>/`. */
+export declare function pluginPathPrefix(id: string): string;
+/**
+ * Accepts what a plugin's bundle exported only when it keeps to its own namespace (ADR-0100):
+ * the contract it was built for, its own id, routes and navigation under `p/<id>/`, slot entries
+ * named `<id>.…`, only the stream topics its descriptor declared, and navigation and administration
+ * groups the shell has. Every component it contributes to a shared screen is wrapped so a throw stays its own.
+ */
+export declare function checkPlugin(entry: ManifestFeatureView, exported: unknown): Checked;

package/types/kernel/registry.d.ts

@@ -0,0 +1,12 @@
+import type { NavContribution, RahdarFeature } from './feature.ts';
+import { type NavGroupId } from './nav/groups.ts';
+export interface NavGroup {
+    id: NavGroupId;
+    label: string;
+    items: NavContribution[];
+}
+/**
+ * The features' views under the kernel's groups (ADR-0070): groups in their fixed order, views in
+ * their declared order, and a group none of the features contributes to left out.
+ */
+export declare function navGroups(features: RahdarFeature[]): NavGroup[];

package/types/kernel/routing/roots.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentType, type ReactElement } from 'react';
+import type { ModuleId } from '../feature.ts';
+/** The root every page renders inside: the shell. A feature's `routes.root` are its children. */
+export declare const rootRoute: import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;
+/** One cluster's layout. A feature's `routes.cluster` are its children. */
+export declare const clusterRoute: import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "clusters/$clusterId", "/clusters/$clusterId", string, "/clusters/$clusterId", undefined, import("@tanstack/router-core").ResolveParams<"clusters/$clusterId">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;
+export declare const pluginClusterFallback: import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "clusters/$clusterId", "/clusters/$clusterId", string, "/clusters/$clusterId", undefined, import("@tanstack/router-core").ResolveParams<"clusters/$clusterId">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "p/$pluginId/$", "/clusters/$clusterId/p/$pluginId/$", string, "/clusters/$clusterId/p/$pluginId/$", undefined, import("@tanstack/router-core").ResolveParams<"p/$pluginId/$">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;
+/** The shell's own pages, beside the cluster layout. */
+export declare const shellRoutes: (import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "/", "/", string, "/", undefined, import("@tanstack/router-core").ResolveParams<"/">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "login", "/login", string, "/login", undefined, import("@tanstack/router-core").ResolveParams<"login">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "admin", "/admin", string, "/admin", (raw: Record<string, unknown>) => {
+    tab?: string;
+    plugin?: string;
+    upload?: string;
+    view?: "retention" | "health";
+    team?: string;
+    teamTab?: string;
+    teamQ?: string;
+    teamSort?: string;
+}, import("@tanstack/router-core").ResolveParams<"admin">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "account", "/account", string, "/account", undefined, import("@tanstack/router-core").ResolveParams<"account">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "inbox", "/inbox", string, "/inbox", (raw: Record<string, unknown>) => {
+    filter?: "unread";
+}, import("@tanstack/router-core").ResolveParams<"inbox">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "approvals", "/approvals", string, "/approvals", (raw: Record<string, unknown>) => {
+    tab?: "mine";
+}, import("@tanstack/router-core").ResolveParams<"approvals">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "approvals/$id", "/approvals/$id", string, "/approvals/$id", undefined, import("@tanstack/router-core").ResolveParams<"approvals/$id">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined> | import("@tanstack/react-router").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/router-core").Register, undefined, {}, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "p/$pluginId/$", "/p/$pluginId/$", string, "/p/$pluginId/$", undefined, import("@tanstack/router-core").ResolveParams<"p/$pluginId/$">, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, import("@tanstack/router-core").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>)[];
+/** A feature's view, or the page explaining that the feature is disabled on this installation (feature-modules spec). */
+export declare function featureView(feature: ModuleId, View: ComponentType): () => ReactElement;

package/types/kernel/shell/AccountView.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The signed-in user's own page: who you are, the approval requests you made while approvals are on
+ * (what a requester comes back for, so it comes first), then what the features contribute — how to
+ * change your password, the keys you hold, how to connect an assistant with one, and your display
+ * preferences. Prose and forms keep a readable width; a section with a table keeps the page's.
+ *
+ * <p>API keys used to live under Administration, which made a per-user
+ * credential look like an operator's tool and hid it from everyone without
+ * {@code user:admin}. Every user has an account, so this route is ungated.
+ */
+export declare function AccountView(): import("react").JSX.Element;

package/types/kernel/shell/AdminView.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rahdar-wide administration (authorization spec): one section per contribution, such as users, roles,
+ * environments and identity provider group mappings, under fixed headings — who may do what, what is
+ * installed, what rules data and changes follow, then support (operator-ui spec). The open section is in
+ * the URL. Each panel brings its own heading.
+ */
+export declare function AdminView(): import("react").JSX.Element;

package/types/kernel/shell/Breadcrumb.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Where the operator is inside a cluster (ADR-0109): cluster › group › view › open resource. The
+ * last crumb is the current page, at text colour; the ones before it that are places are dimmed links
+ * back to them, and a group, which is not a place, is dimmed text.
+ */
+export declare function Breadcrumb(): import("react").JSX.Element | null;

package/types/kernel/shell/ClusterLayout.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One cluster's screen: one context line, then the routed view, whose own `PageHeader` is the page's
+ * one h1 (ADR-0163). The line is the breadcrumb at its start and, at its end, whatever a
+ * `cluster.header` contribution marks with `data-context-line` (the clusters feature's environment,
+ * nodes and health); every other part of a contribution, such as a health notice, takes a row of its
+ * own below the line. Nothing in it is a heading.
+ *
+ * It hosts the dialogs row actions open (ADR-0107), and mounts the cluster's one SSE stream, subscribed
+ * to the topics of every enabled feature (ADR-0018, ADR-0070). A view never opens a second one for a
+ * topic a feature handles: a second `EventSource` is a second connection. The stream reconnects
+ * indefinitely and reports its state to the header's freshness indicator (ADR-0052); while it is down
+ * the per-hook refetch intervals keep every view updating.
+ */
+export declare function ClusterLayout(): import("react").JSX.Element;

package/types/kernel/shell/ClusterViewNav.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The per-cluster view nav (ADR-0034), grouped (ADR-0070). Each enabled feature contributes its
+ * views to one of the kernel's groups; a group with no enabled view is not shown. Expanded, a group
+ * has a visible title; collapsed, a rule in the title's place, and its title stays available to a screen reader. The title
+ * names its group but is not a heading: the page's headings are the page's own, starting at its one h1.
+ * A view the operator lacks the read permission for stays listed and disabled, with the reason:
+ * a missing entry would read as a product that cannot do it. Only rendered while a cluster is the
+ * active route.
+ */
+export declare function ClusterViewNav({ clusterId, collapsed }: Readonly<{
+    clusterId: string;
+    collapsed: boolean;
+}>): import("react").JSX.Element;

package/types/kernel/shell/CommandPalette.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ⌘K navigation across the console: jump to a view, a recent place, a cluster, or a queue by name, or
+ * search a live view (ADR-0109). Mounted once in the root layout; the shortcut is registered by
+ * {@link Spotlight}, and the header's Search button opens it too.
+ *
+ * The typed query reaches the features' sources, debounced, together with whether the palette is
+ * open, so a source searches only while someone is looking — and only what Rahdar already holds.
+ * A view the operator may not open is still listed, disabled, with the reason: the rail shows it the
+ * same way.
+ *
+ * Pause is here too, so every header control is reachable from the keyboard without a hotkey of its
+ * own (ADR-0052, ADR-0118), and so are the user menu's colour scheme and table density (ADR-0159,
+ * ADR-0162).
+ */
+export declare function CommandPalette(): import("react").JSX.Element;

package/types/kernel/shell/FeatureDisabled.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What a disabled feature's address shows (feature-modules spec): that the feature is off on this
+ * installation rather than missing or broken, the startup property that turns it on, and the way
+ * back. Never a blank page or a not-found, which would teach the operator the view does not exist.
+ */
+export declare function FeatureDisabled({ title, property, clusterId, }: Readonly<{
+    /** The feature's title, as the manifest names it. */
+    title: string;
+    /** The startup property that enables it, as the manifest names it. */
+    property: string;
+    /** The cluster the address belongs to, when it is a cluster view. */
+    clusterId?: string;
+}>): import("react").JSX.Element;

package/types/kernel/shell/FeatureGate.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { ModuleId } from '../feature.ts';
+/**
+ * A feature's view, or the page that explains the feature is disabled on this installation
+ * (feature-modules spec). It waits for the manifest rather than rendering a disabled view whose
+ * every request would fail as not found. If the manifest cannot be read the view renders: the
+ * server still refuses a disabled feature's calls, so nothing is exposed by trying.
+ */
+export declare function FeatureGate({ feature, children }: Readonly<{
+    feature: ModuleId;
+    children: ReactNode;
+}>): import("react").JSX.Element;

package/types/kernel/shell/FreshnessBar.d.ts

@@ -0,0 +1,11 @@
+export type FreshnessState = 'live' | 'polling' | 'reconnecting' | 'offline' | 'paused';
+/**
+ * The one place that answers "is this current?" — in the header, on every route
+ * (ADR-0052).
+ *
+ * Stream health and data health are separate states. A cluster whose stream is
+ * down but whose queries are succeeding is `Polling`, not `Offline`; conflating
+ * them would cry wolf on every proxy hiccup. A route that mounts no stream is
+ * `Polling` too, which is the literal truth there.
+ */
+export declare function FreshnessBar(): import("react").JSX.Element;

package/types/kernel/shell/GlobalContext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The strip above a page outside any cluster: the way back to where the operator was, and where they
+ * are. These pages have no sidebar, because it would only hold a cluster picker; this line is how an
+ * operator leaves them, in one click, for the view they came from. With no previous place it offers
+ * to open a cluster.
+ */
+export declare function GlobalContext(): import("react").JSX.Element;