@sparkelf/dsh-knowledge-base 0.0.0-stage → 0.1.0

package/lib/types/client/KnowledgeMenuIcon.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The glyph the left sidebar renders for the knowledge-base entry.
+ *
+ * `sidebar.panellist` is a list of icon buttons, so this component receives only a
+ * size and never renders a surface. The page the entry selects is a separate
+ * component registered against the `main` key.
+ *
+ * The glyph is the product's own icon component rather than a local path: the rail
+ * sits directly beside the other panel icons, and a hand-drawn stroke read visibly
+ * heavier than its neighbours. Using the product icon keeps the rail uniform and
+ * lets the size the sidebar passes through unchanged.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** Props the sidebar list passes to one entry. */
+export interface KnowledgeMenuIconProps {
+    /** Glyph edge length in pixels, chosen by the sidebar for its current width. */
+    size?: number;
+    /** Whether this entry is the selected panel. */
+    active?: boolean;
+}
+/**
+ * Render the knowledge-base glyph.
+ * @param props - sidebar-supplied glyph size.
+ * @returns The product icon sized for the sidebar rail.
+ */
+export declare function KnowledgeMenuIcon(props: KnowledgeMenuIconProps): import("react").JSX.Element;

package/lib/types/client/KnowledgePanel.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The knowledge-base management page.
+ *
+ * Selected by the left-sidebar entry and rendered into the `main` slot, so it
+ * replaces the conversation area. The page carries its own master-detail layout:
+ * the rail holds a menu above the knowledge tree, and the content region shows
+ * whichever surface the rail selected (a file preview, permissions, or indexing).
+ *
+ * The tree is this package's own listing rather than the file component from
+ * `dsh-better-sidebar`. That component renders icon and name only and builds its
+ * context menu internally, so it has nowhere to show whether a row is readable and
+ * nowhere to add a grant entry, while the actions its menu does offer (rename,
+ * delete, upload) edit a shared curated store rather than deciding who may see a
+ * document. The one thing worth keeping from it is the `@`-reference action, reused
+ * through its own helper so both trees insert the same reference.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/**
+ * The session binding the page scopes its file tree with.
+ *
+ * It is a subscribable observable rather than a plain value because the session it
+ * names appears only after a Workspace is chosen, which regularly happens after
+ * this page has already mounted.
+ */
+export interface SessionSource {
+    /** Current binding; `key` is the session id, absent before a session exists. */
+    getSnapshot: () => {
+        key?: unknown;
+    };
+    /** Subscribe to changes; returns the unsubscribe function. */
+    subscribe: (listener: () => void) => () => void;
+}
+/** Values the `main` slot injects into the page. */
+export interface KnowledgePanelInjected {
+    /** Locale-bound copy for this package's namespace. */
+    t: (key: string) => string;
+    /** Locale tag the slot bound for this namespace, so dates match the reader. */
+    locale?: string;
+    /** Source of the session the file tree resolves its scope from. */
+    sessionSource: SessionSource;
+    /**
+     * The client context, needed by the borrowed tree's `@` helper.
+     *
+     * That helper resolves the workspace root and the conversation input service
+     * itself, so it needs the context rather than the values it reads from it.
+     */
+    ctx: unknown;
+}
+/** Props the page receives. */
+export interface KnowledgePanelProps extends Partial<KnowledgePanelInjected> {
+}
+/**
+ * Render the knowledge-base management page.
+ * @param props - injected locale copy and the current session id.
+ * @returns The master-detail page.
+ */
+export declare function KnowledgePanel(props: KnowledgePanelProps): import("react").JSX.Element;

package/lib/types/client/KnowledgePermissionOverview.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The permissions surface: one grant table, read two ways.
+ *
+ * A grant says "this principal may do this action to this path". That is the right
+ * shape to STORE and the wrong shape to AUDIT: an administrator asking "what does
+ * 张三 have" and "who can see 制度.md" is asking two questions that one
+ * row-per-grant layout cannot answer without being read line by line.
+ *
+ * So the page has one body and two readings of it. The tabs switch which question
+ * is being asked; both render the same loaded grants, so the two can never
+ * disagree. No second endpoint exists because there is no second truth.
+ *
+ * The tables are the page's own body rather than a summary above one. An earlier
+ * version stacked both readings as bulleted lists and *also* drew a third,
+ * row-per-principal table underneath: three renderings of one payload, so the
+ * reader had to work out which of the three was authoritative before reading any
+ * of them. Two tabs over one table removes that question.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client/KnowledgePermissionOverview
+ */
+import type { GrantView, KnowledgeGrantSubjectType } from '../api.ts';
+import { type RoleSummary } from './roleSummary.ts';
+/** Which reading of the grant table the tabs are showing. */
+export type OverviewTab = 'person' | 'resource';
+/** Copy for the overview, supplied by the caller's locale record. */
+export interface OverviewCopy {
+    tabByPerson: string;
+    tabByResource: string;
+    empty: string;
+    pathsHeld: (count: number) => string;
+    rolesHeld: string;
+    actionsHeld: string;
+    builtInRoles: string;
+    noActions: string;
+    /** Accessible name for the tab strip, for readers who arrive at it by keyboard. */
+    tabsLabel: string;
+    /** Stat-card labels: the four numbers the page leads with. */
+    statPrincipals: string;
+    statResources: string;
+    statGrants: string;
+    statRoles: string;
+    /** Shared column headers, person reading. */
+    colPrincipal: string;
+    colKind: string;
+    colPermission: string;
+    colResources: string;
+    colExpiry: string;
+    colActions: string;
+    /** Shared column headers, resource reading. */
+    colResource: string;
+    colHolders: string;
+    colKindOfResource: string;
+    revoke: string;
+    revokeBusy: string;
+    expiryNever: string;
+    kindFile: string;
+    kindDirectory: string;
+    /** Formats "N grants · M paths" under a person's name. */
+    grantsUnit: (count: number) => string;
+    resourcesUnit: (count: number) => string;
+    /**
+     * Resolves a principal kind and an action to its localized word.
+     *
+     * Supplied as callbacks rather than as a keyed map so this component never
+     * reaches into the locale record itself: a caller with its own wording (a test,
+     * another surface) can pass its own, and the type checker still enforces that
+     * every kind and action the table can print has a word.
+     */
+    kindLabel: (kind: KnowledgeGrantSubjectType) => string;
+    actionLabel: (action: string) => string;
+}
+/** Props the parent panel supplies. */
+export interface KnowledgePermissionOverviewProps {
+    /** The grant table already loaded by the permissions page. */
+    grants: readonly GrantView[];
+    /** Display names by `principalType:principalId`. */
+    labels?: Readonly<Record<string, string>>;
+    /** Built-in role summaries, so the person view can explain what a role means. */
+    roles?: readonly RoleSummary[];
+    /** Locale copy. */
+    copy: OverviewCopy;
+    /**
+     * Asks the parent to confirm revoking the grants one row covers.
+     *
+     * The confirmation lives in the parent because it is a dialog, and a dialog in
+     * the middle of a table's row renderer would make the table responsible for
+     * ownership of the overlay. This component says *what* to revoke; the parent
+     * decides whether to ask first and then performs it.
+     */
+    onRevoke: (grants: GrantView[], label: string) => void;
+    /** Disables every revoke control while a write is in flight. */
+    busy?: boolean;
+}
+/**
+ * Render the permission overview as stat cards over a two-tab table.
+ *
+ * @param props - grants, labels, role summaries, locale copy and the revoke hook.
+ */
+export declare function KnowledgePermissionOverview(props: KnowledgePermissionOverviewProps): import("react").JSX.Element;

package/lib/types/client/KnowledgePermissions.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The permissions surface of the management page.
+ *
+ * This view reads and writes grants through the DSH Host, which forwards them to
+ * the DataOps backend. It deliberately holds no policy of its own: the backend's
+ * authorization resolves the principal, checks the caller's permission keys, and
+ * enforces what a grant means. The page only presents the result, so a rule
+ * change lands in one place.
+ *
+ * The page leads with its table. A grant list is what an operator opens this
+ * surface to read, so the data is the body of the page and the two things that
+ * CHANGE it -- creating a grant, revoking one -- are raised into dialogs. A form
+ * parked above the table would push the answer below the fold to make room for
+ * the question.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+import { type ReactNode } from 'react';
+/** Props for the permissions surface. */
+export interface KnowledgePermissionsProps {
+    /**
+     * Publishes this page's primary control to the panel header.
+     *
+     * The header is the only band at the top of the page, so a page-level action has
+     * to be handed up rather than drawn in a second title row.
+     */
+    onAction?: (action: ReactNode) => void;
+    /** Locale-bound copy resolver. */
+    t: (key: string) => string;
+    /** Mount point the grants are scoped to. */
+    mountPoint: string;
+    /** Path the user selected, when the surface opened from a file row. */
+    initialPath?: string;
+    /**
+     * Changes when a row's context menu picks a new path.
+     *
+     * The form's path field is seeded from `initialPath` once; without a signal that
+     * the seed changed, a second right-click would leave the field on the first path.
+     */
+    reloadToken?: number;
+}
+/**
+ * Render the permission editor.
+ * @param props - copy resolver and the mount point grants are scoped to.
+ * @returns The permission surface.
+ */
+export declare function KnowledgePermissions(props: KnowledgePermissionsProps): import("react").JSX.Element;

package/lib/types/client/KnowledgeReferencePicker.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The `@`-mention picker: choose which conversation a knowledge file goes into.
+ *
+ * The explorer row's `@` button used to answer `if (sessionId === undefined) return`
+ * -- a page with no conversation open simply dropped the click, so the button looked
+ * broken. But "no conversation open" is exactly the state this page is in most of the
+ * time: it is a management surface, not a chat. The reference still has to land
+ * somewhere, so the click now asks where.
+ *
+ * Two things are deliberately borrowed rather than invented:
+ *
+ * The insertion itself is `referenceInChat`, the same contract the sidebar explorer
+ * and the viewer's selection popup call. That function owns the whole policy this
+ * dialog must not re-derive: which workspace root the mention is relative to, the
+ * chip spelling for files versus folders, the quoted form for paths with spaces, and
+ * the "degrade to a logged no-op" behaviour when a service is missing. Building a
+ * second insertion path here would be the one way to make the two surfaces disagree.
+ *
+ * The session list and the navigation are the host's own services, resolved lazily
+ * through `ctx.get` rather than injected: this dialog is mounted whether or not the
+ * user has ever opened a conversation, and a page that cannot see `uiSession` must
+ * still render (it would show an empty list, not crash).
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** Props for the picker. */
+export interface KnowledgeReferencePickerProps {
+    /** Whether the dialog is showing. */
+    open: boolean;
+    /** Close without referencing anything. */
+    onClose: () => void;
+    /** Absolute path of the entry the `@` button was pressed on. */
+    path: string;
+    /** Whether that entry is a directory (a folder mention rather than a file chip). */
+    isDir: boolean;
+    /** The client context; both the draft insert and the service lookups need it. */
+    ctx: unknown;
+    /** Locale-bound copy for this package's namespace. */
+    t: (key: string) => string;
+    /** Locale tag, so a session's timestamp reads in the reader's language. */
+    locale?: string;
+    /**
+     * The conversation the host currently has selected, read at call time.
+     *
+     * The New Session flow creates a conversation asynchronously and does not return
+     * its id, so the only way to name it afterwards is to ask the page's own session
+     * binding -- the same observable the file tree is scoped by. Reading it lazily
+     * rather than as a prop is what makes it current by the time the draft is ready.
+     */
+    selectedSessionId?: () => string | undefined;
+    /**
+     * Called once a reference was actually inserted, with the session that received it.
+     *
+     * The dialog closes itself either way; this exists so the page can report which
+     * conversation the file went to, which is the only feedback a reader gets when the
+     * target tab is not the one they were looking at.
+     */
+    onReferenced?: (sessionId: string) => void;
+}
+/**
+ * The `@`-mention session picker.
+ * @param props - the entry to reference and the dialog's state.
+ * @returns The dialog, or null while closed.
+ */
+export declare function KnowledgeReferencePicker(props: KnowledgeReferencePickerProps): import("react").JSX.Element;

package/lib/types/client/KnowledgeSearch.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The knowledge base's search: find a document, then open it.
+ *
+ * The field itself lives in the page's rail, not here, because it is navigation:
+ * a reader reaches "find a document" the same way they reach the permission or
+ * indexing section, and a menu row labelled "Search" asked them to click through
+ * to a box before they could type. `useKnowledgeSearch` owns the one piece of
+ * state both halves need, so the rail's field and this result list cannot
+ * disagree about which term produced which hits.
+ *
+ * This replaces an earlier summary of mount state, which answered a question the
+ * operator had not asked: the mount path, the file count, and a sync timestamp are
+ * facts about the deployment, while the reason to open this page is to locate a
+ * document.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** One result row, as the Host returns it. */
+interface SearchHit {
+    /** Path relative to the mount point. */
+    relPath: string;
+    /** File name alone. */
+    name: string;
+    /** Whether the term matched the file body rather than only its name. */
+    inContent: boolean;
+    /** Matching line, when the term was found inside the file. */
+    line?: string;
+    /** 1-based line number of {@link line}. */
+    lineNumber?: number;
+    /** Last-modified instant in Unix ms, when the Host could stat the file. */
+    mtimeMs?: number;
+}
+/** What {@link useKnowledgeSearch} hands back to the rail and the result list. */
+export interface KnowledgeSearchState {
+    /** Current term, owned here so the field and the results read one value. */
+    term: string;
+    /** Replace the term. */
+    setTerm: (value: string) => void;
+    /** Hits for the settled term, empty while idle. */
+    hits: SearchHit[];
+    /** Which surface the result list should draw. */
+    status: 'idle' | 'searching' | 'done' | 'error';
+    /** Index of the keyboard-highlighted row. */
+    active: number;
+    /** Highlight a row, so pointer movement and the arrow keys agree. */
+    setActive: (index: number) => void;
+    /** Arrow-key handling for the rail's field. */
+    onKeyDown: (event: {
+        key: string;
+        preventDefault: () => void;
+    }) => void;
+}
+/**
+ * Own the search term, its debounced request, and the highlighted row.
+ *
+ * Extracted rather than left inside the result component because the field it is
+ * driven by now sits in the rail: a hook keeps one owner for the term while the
+ * input and the list render in different regions of the page.
+ *
+ * @param mountPoint - the mount to search; empty while the page is still loading.
+ * @returns The term, its hits, and the keyboard handler for the field.
+ */
+export declare function useKnowledgeSearch(mountPoint: string): KnowledgeSearchState;
+/** Props for the result list. */
+export interface KnowledgeSearchProps {
+    /** Locale-bound copy resolver. */
+    t: (key: string) => string;
+    /** Term and hits, owned by {@link useKnowledgeSearch}. */
+    search: KnowledgeSearchState;
+    /** Called with the chosen path so the page can show its preview. */
+    onOpen: (path: string) => void;
+    /** Locale tag, used to render dates and relative spans in the reader's language. */
+    locale?: string;
+    /** Shown while no term is entered, so the surface is useful before searching. */
+    idle?: React.ReactNode;
+}
+/**
+ * Render the results for the rail's search field.
+ * @param props - copy resolver, the search state, and the open callback.
+ * @returns The result list, or the idle content when nothing is typed.
+ */
+export declare function KnowledgeSearch(props: KnowledgeSearchProps): import("react").JSX.Element;
+export {};

package/lib/types/client/KnowledgeSectionHeader.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The rail's section bands: a name with an optional trailing glyph cluster.
+ *
+ * Copied from the shell's own browser header,
+ * `ui-workspace/src/client/rows/WorkspaceBrowser.module.css` (`.sectionHeader` /
+ * `.sectionLabel` + `.iconButton`). That band is the one a reader compares this
+ * page against, because it is what the right sidebar shows for 工作区 in the same
+ * window. The metrics were also measured live on the running shell on 2026-10-17
+ * and agree with the stylesheet exactly: a 36px row, `gap: 4px`,
+ * `padding-left: 4px`, a label at 14px/20px, and 28x28 buttons on an 8px radius.
+ *
+ * Two details are the stylesheet's own and easy to get wrong:
+ *
+ * - The label is *not* bold. `--dsw-font-s-14` is 14px/22px, while this band's
+ *   line-height is an explicit 20px, so the shorthand is paired with the measured
+ *   line-height rather than allowed to win.
+ * - The name inherits the band's ink, which the stylesheet sets to
+ *   `--dsw-alias-label-tertiary`; the buttons carry
+ *   `--dsw-alias-label-secondary` of their own. Measured live, the name is
+ *   `#adb2b8` and the buttons `#cfd3d6`, which is that same split.
+ *
+ * The band is a plain `div` with a name span and a button cluster rather than a
+ * heading element: it labels a region that already carries its own landmark, and
+ * a second heading level here would put an unlabelled h3 in the heading outline.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+import type { ReactNode } from 'react';
+/** Props for one section band. */
+export interface KnowledgeSectionHeaderProps {
+    /** Localized section name, rendered at the measured 14px/20px. */
+    name: ReactNode;
+    /**
+     * The trailing controls.
+     *
+     * Optional because the pinned band's only control is the fold toggle, while
+     * the tree band carries three; a band with none renders the name alone.
+     */
+    actions?: ReactNode;
+    /** Extra class for the band, so a caller can add its own spacing. */
+    className?: string;
+}
+/**
+ * Render one section band.
+ * @param props - the name, its trailing controls, and optional placement.
+ * @returns The band.
+ */
+export declare function KnowledgeSectionHeader(props: KnowledgeSectionHeaderProps): import("react").JSX.Element;
+/** Props for one 28px glyph button in a band's cluster. */
+export interface KnowledgeIconButtonProps {
+    /** Localized accessible name; also the tooltip, as the shell's own buttons do. */
+    label: string;
+    /** The glyph, sized by the caller to the band's 16px step. */
+    children: ReactNode;
+    /** Invoked on activation. */
+    onClick: () => void;
+    /** Whether the control refuses activation. */
+    disabled?: boolean;
+    /** Whether the control's action is currently engaged, so it can report `aria-pressed`. */
+    pressed?: boolean;
+}
+/**
+ * Render one glyph button.
+ *
+ * A native button with the band's own class rather than the `Button` primitive:
+ * that primitive is the product's labelled action at a 36px control height, while
+ * this is the 28x28 icon control the band is specified around.
+ * @param props - the accessible name, glyph, and activation handler.
+ * @returns The button.
+ */
+export declare function KnowledgeIconButton(props: KnowledgeIconButtonProps): import("react").JSX.Element;

package/lib/types/client/KnowledgeSelectionBar.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The batch action bar that closes a multi-select session in the tree.
+ *
+ * Copied from the explorer's own `explorerSelectionBar` (`FileTree.tsx:2238`,
+ * `sidebar.module.css:932`): the same `role="toolbar"`, the same sticky bottom
+ * position, the same 28px minimum height, the same `bg-layer-2` fill and 4px
+ * radius, and the same split between a shrinking count on the left and the
+ * actions on the right. It is a copy rather than a second design because a reader
+ * sees that bar in this window's right sidebar, and the two are the same gesture.
+ *
+ * The actions are deliberately only the two this build can actually perform.
+ * Delete is absent because the trash has no decided retention or ownership
+ * semantics, and a destructive button wired to an undecided policy is worse than
+ * no button: the explorer's own bar carries delete, so its absence here is a
+ * decision rather than an oversight.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** Props for the batch bar. */
+export interface KnowledgeSelectionBarProps {
+    /** Locale-bound copy resolver. */
+    t: (key: string, params?: Record<string, string | number>) => string;
+    /** How many rows are selected, for the count and the label. */
+    count: number;
+    /** Move every selected path into one folder the reader picks. */
+    onMove: () => void;
+    /** Pin every selected path. */
+    onPin: () => void;
+    /** Drop the selection. */
+    onClear: () => void;
+    /**
+     * Whether a batch write is in flight, so the actions can be held.
+     *
+     * A second click while the first is still moving would send the same paths twice,
+     * and the second would be refused as a missing source -- an error the reader
+     * would read as the feature being broken.
+     */
+    busy?: boolean;
+}
+/**
+ * Render the batch bar for the current selection.
+ * @param props - the count, the three actions, and the busy flag.
+ * @returns The toolbar.
+ */
+export declare function KnowledgeSelectionBar(props: KnowledgeSelectionBarProps): import("react").JSX.Element;

package/lib/types/client/KnowledgeSettings.d.ts

@@ -0,0 +1,96 @@
+/**
+ * TODO: this page is unreachable from the real entry, and needs a decision.
+ *
+ * Verified by driving the deployed product on 2026-10-21, not by reading the code:
+ * entering 知识库 and clicking 「设置」 in its own rail opens the DSH GLOBAL settings
+ * dialog (left nav: 通用设置/模型/内置插件/Agent 预设/DataOps/备份/知识库/插件市场/
+ * 侧边卡片), never this component. The rail row sets `selection.kind = 'settings'`,
+ * which `KnowledgePanel.tsx` renders as this surface, but the click that a reader can
+ * actually reach is the shell's own settings entry, so nothing in the real UI leads
+ * here. The review switch below therefore has no user-facing effect today.
+ *
+ * Deliberately NOT deleted: removing this file, the `rendered.kind === 'settings'`
+ * branch in `KnowledgePanel.tsx` and the `menu.settings` rail row is a cross-file
+ * structural change, and the choice between "delete the page" and "give it a real
+ * entry point" is a product decision rather than a cleanup. Left as-is with this note
+ * so the next change starts from the measured fact instead of re-deriving it.
+ *
+ * What WAS moved: the MinerU service address. It lived here for one round and was
+ * invisible to readers for exactly this reason; it now renders in
+ * `KnowledgeSettingsSection.tsx` (DSH global settings → 知识库), which is reachable.
+ */
+/**
+ * The settings surface of the management page.
+ *
+ * This page is now only the review switch: a DECISION about whether other people's
+ * contributions take effect immediately, so it is a control and it needs write
+ * access. The queue that decision governs and the trail of what it settled both
+ * moved to the Audit page, which is the surface an operator opens to get through
+ * work; parking a worklist under a configuration switch made them scroll past the
+ * setting to reach today's arrivals, and left two duplicate entry points pointing
+ * at the same two tables.
+ *
+ * The switch ships OFF. That is the product decision, not a default that drifted: an
+ * operator who never opens this page keeps the behaviour they had, and turning review
+ * on is a deliberate act with a visible consequence.
+ *
+ * @module @sparkelf/dsh-knowledge-base/client
+ */
+/** This knowledge base's review settings, as the Host reports them. */
+export interface KnowledgeSettingsView {
+    /** Whether a write must be reviewed before it counts as published. */
+    reviewRequired: boolean;
+    /**
+     * MinerU's full base address, or `''` to derive it from the configured port.
+     *
+     * Absent from an older Host's answer, which reads as `''`: the field then shows
+     * "derived" rather than a value the Host never sent.
+     */
+    mineruBaseUrl?: string;
+}
+/** One recorded change, as the Host reports it. */
+export interface KnowledgeAuditEntryView {
+    /** ISO timestamp of the action. */
+    at: string;
+    /** DataOps user id that performed it: the identity the trail is checked against. */
+    actor: string;
+    /**
+     * That user's display name, when the entry carries one.
+     *
+     * Absent on entries written before it was recorded; the column falls back to the
+     * id so an old line still identifies its actor.
+     */
+    actorLabel?: string;
+    /** What they did. Mirrors the Host's own action union. */
+    action: 'create' | 'upload' | 'move' | 'approve' | 'reject' | 'edit';
+    /** The path the action concerned. */
+    relPath: string;
+    /** For a move, the destination path. */
+    toRelPath?: string;
+    /** Whether it took effect immediately or was parked for review or refused. */
+    outcome: 'applied' | 'pending' | 'rejected';
+}
+/** Props for the settings surface. */
+export interface KnowledgeSettingsProps {
+    /** Locale-bound copy for this package's namespace. */
+    t: (key: string) => string;
+}
+/** One submission waiting for review, as the Host reports it. */
+export interface PendingWriteView {
+    /** The parking name a decision is made against. */
+    name: string;
+    /** Who submitted it. */
+    userId: string;
+    /** The path it wants to occupy. */
+    relPath: string;
+    /** When it was submitted. */
+    at: string;
+    /** Size of the submitted bytes. */
+    bytes: number;
+}
+/**
+ * Render the review switch and the audit trail.
+ * @param props - copy resolver.
+ * @returns The settings surface.
+ */
+export declare function KnowledgeSettings(props: KnowledgeSettingsProps): import("react").JSX.Element;

package/lib/types/client/KnowledgeSettingsSection.d.ts

@@ -0,0 +1,21 @@
+import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
+import type { en } from './locales.ts';
+/** Values injected by the DSH Settings slot. */
+export interface KnowledgeSettingsInjected {
+    /** Translate one knowledge-base message key. */
+    t: (key: keyof typeof en) => string;
+}
+/** Props accepted by the injected Settings section. */
+export type KnowledgeSettingsProps = Partial<InjectFace<KnowledgeSettingsInjected>>;
+/**
+ * Render the knowledge-base connection, resolved paths, status, the read-only
+ * authorization summary, and the deployment wizard.
+ *
+ * Authorization itself is deliberately absent: DataOps owns grants, and this
+ * panel only reports what the backend says (AGENTS.md "Managed DataOps
+ * Authorization" forbids replicating that policy in a plugin).
+ *
+ * @param props - Settings slot injection values.
+ * @returns The localized Settings section, or nothing before injection.
+ */
+export declare function KnowledgeSettingsSection(props: KnowledgeSettingsProps): import("react").JSX.Element | null;