@meshmakers/shared-ui 3.4.1480 → 3.5.0

package/types/meshmakers-shared-ui-assistant.d.ts

@@ -0,0 +1,258 @@
+import { AssistantService, AssistantMessages, AssistantPanelMode, AssistantSessionSummary, AssistantProposalDecision, AssistantAttachmentOptions, AssistantSlashCommand, AssistantThreadItem, AssistantProposal, AssistantProposalDecisionKind } from '@meshmakers/shared-ui/assistant-core';
+export { ASSISTANT_ENABLED, ASSISTANT_MESSAGES, ASSISTANT_NOT_CONNECTED_MESSAGE, ASSISTANT_PAGE_CONTEXT, ASSISTANT_PANEL_OPTIONS, ASSISTANT_SLASH_COMMANDS, ASSISTANT_TOOL_CALL_COMPONENT, ASSISTANT_TRANSPORT, AssistantAsyncResult, AssistantAttachmentOptions, AssistantAttachmentRef, AssistantAttachmentSelection, AssistantContextChip, AssistantContextKind, AssistantContextSource, AssistantExplainDirective, AssistantExplainTarget, AssistantMessages, AssistantOpenRequest, AssistantPageContext, AssistantPanelMode, AssistantPanelOptions, AssistantProposal, AssistantProposalDecision, AssistantProposalDecisionKind, AssistantSendRequest, AssistantService, AssistantSessionSummary, AssistantSlashCommand, AssistantStarterQuestions, AssistantStreamEvent, AssistantThreadItem, AssistantToolCall, AssistantToolCallRowComponent, AssistantTransport, AssistantTransportStatus, DEFAULT_ASSISTANT_MESSAGES, DEFAULT_ASSISTANT_PANEL_MAX_WIDTH, DEFAULT_ASSISTANT_PANEL_MIN_WIDTH, DEFAULT_ASSISTANT_PANEL_STORAGE_KEY, DEFAULT_ASSISTANT_SLASH_COMMANDS, FakeAssistantTransport, IfAssistantDirective, NotConnectedAssistantTransport, assistantFileAccepted, assistantHotkey, deriveAssistantContext, formatAssistantFileSize, formatAssistantMessage, proposalDecisionLabel, resolveAssistantMessages, selectAssistantAttachments } from '@meshmakers/shared-ui/assistant-core';
+import * as _angular_core from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import * as _progress_kendo_svg_icons from '@progress/kendo-svg-icons';
+
+/** Classifies a link target: external (http/https/mailto), relative (same origin) or unsafe. */
+declare function classifyAssistantHref(href: string | null | undefined): 'external' | 'relative' | 'unsafe';
+/** Renders untrusted assistant markdown to HTML with the rules above. */
+declare function renderAssistantMarkdown(markdown: string): string;
+/** `{{ text | assistantMarkdown }}` for `[innerHTML]` bindings. */
+declare class AssistantMarkdownPipe implements PipeTransform {
+    transform(markdown: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssistantMarkdownPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<AssistantMarkdownPipe, "assistantMarkdown", true>;
+}
+
+/**
+ * Right-side assistant panel (ui-concept §5.3, wireframe screen 6): header,
+ * removable context chips, thread, composer. Non-modal: the page stays usable.
+ * Opening focuses the composer, Esc closes and focus returns to where it was
+ * (AssistantService). Below 640 px it covers the screen under the top bar and
+ * becomes a modal dialog (`aria-modal`, Tab trapped) so the page behind is out
+ * of reach. Removing a context chip moves focus to the next chip, else the composer.
+ *
+ * Host it only while {@link AssistantService.enabled} is set and the panel is open
+ * (`@if (assistant.enabled && assistant.isOpen()) { <mm-assistant-panel /> }`); the thread
+ * lives in the service, so closing and navigating keep it.
+ *
+ * Optional transport capabilities (AB#5621) add UI only when the transport has them:
+ * - **sessions** — "New chat" and "Chats" in the header; the chat list replaces the thread
+ *   (open a chat, delete with an inline confirmation; Esc returns to the chat);
+ * - **starter questions** — shown as buttons on an empty thread; clicking one sends it;
+ * - **attachments** — the composer's "Attach file" button (see `mm-assistant-composer`).
+ *
+ * Header actions ("New chat", "Chats", close) are icon buttons with tooltip and `aria-label` from
+ * the messages, so they never wrap in a narrow panel (AB#5621).
+ *
+ * **Layout (AB#5621)** — inputs, else {@link ASSISTANT_PANEL_OPTIONS}, else the defaults:
+ * - `resizable` (default `false`, so no handle and no extra tab stop; opt in per input or token):
+ *   a handle on the left edge (`role="separator"`) changes the width by dragging or with ←/→
+ *   (Shift: bigger steps), Home/End (min/max); a double click forgets the chosen width. The width
+ *   stays within `minWidth`..`maxWidth` (320..720 px, and at least 240 px of the window stay free)
+ *   and is kept in `localStorage` under `storageKey` (`mm-assistant-panel-width`; `null` = not
+ *   kept). Without `resizable`, or until someone resizes it, the panel keeps its CSS width (400 px,
+ *   340 px ≤ 1180 px). Unavailable storage only means the width is not kept.
+ * - `mode`: `docked` (default, pushes the content) or `overlay` (floats over it, `position: fixed`
+ *   at the right edge below `--mm-assistant-overlay-top`, default 48 px; stacking via
+ *   `--mm-assistant-overlay-z-index`, default 20).
+ * On phones neither applies: the panel is the full-screen dialog.
+ */
+declare class AssistantPanelComponent {
+    protected readonly assistant: AssistantService;
+    private readonly injector;
+    private readonly host;
+    private readonly composer;
+    /** Translations; members left out fall back to {@link ASSISTANT_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<AssistantMessages> | null>;
+    protected readonly m: _angular_core.Signal<AssistantMessages>;
+    /** `docked` pushes the content, `overlay` floats over it (default: options token, else `docked`). */
+    readonly mode: _angular_core.InputSignal<AssistantPanelMode | null>;
+    /** Shows the resize handle (default: options token, else `false`). */
+    readonly resizable: _angular_core.InputSignal<boolean | null>;
+    /** Smallest width in px of the resize handle (default: options token, else 320). */
+    readonly minWidth: _angular_core.InputSignal<number | null>;
+    /** Largest width in px of the resize handle (default: options token, else 720). */
+    readonly maxWidth: _angular_core.InputSignal<number | null>;
+    /**
+     * `localStorage` key of the chosen width; `null` = not kept. Left out (`undefined`): options
+     * token, else `mm-assistant-panel-width`.
+     */
+    readonly storageKey: _angular_core.InputSignal<string | null | undefined>;
+    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly plusIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly historyIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly trashIcon: _progress_kendo_svg_icons.SVGIcon;
+    private readonly options;
+    protected readonly effectiveMode: _angular_core.Signal<AssistantPanelMode>;
+    protected readonly overlay: _angular_core.Signal<boolean>;
+    private readonly effectiveStorageKey;
+    protected readonly effectiveMin: _angular_core.Signal<number>;
+    protected readonly effectiveMax: _angular_core.Signal<number>;
+    /** The handle is shown (never on phones). */
+    protected readonly canResize: _angular_core.Signal<boolean>;
+    /** Width chosen in this panel instance; `undefined` = not touched yet (stored width applies). */
+    private readonly chosenWidth;
+    private readonly storedWidth;
+    /** The inline width in px, or null for the CSS default. */
+    protected readonly appliedWidth: _angular_core.Signal<number | null>;
+    /** CSS width as rendered, for `aria-valuenow` before the first resize. */
+    private readonly measuredWidth;
+    protected readonly currentWidth: _angular_core.Signal<number>;
+    protected readonly resizing: _angular_core.WritableSignal<boolean>;
+    private stopDrag;
+    /** Phone layout (≤ 640 px, the shell's breakpoint): the panel is a modal dialog. */
+    protected readonly isPhone: _angular_core.WritableSignal<boolean>;
+    protected readonly connected: _angular_core.Signal<boolean>;
+    /** `chat` = thread + composer; `sessions` = the saved chats list (session-capable transports only). */
+    protected readonly view: _angular_core.WritableSignal<"chat" | "sessions">;
+    /** Session whose deletion waits for confirmation. */
+    protected readonly confirmingDelete: _angular_core.WritableSignal<string | null>;
+    /** Session being opened or deleted (its buttons are disabled meanwhile). */
+    protected readonly busySession: _angular_core.WritableSignal<string | null>;
+    /**
+     * Greeting of an empty chat (AB#3444): the OctoBot waves once, then rests on its still frame.
+     * Not shown while the assistant is unavailable (the panel says so instead).
+     */
+    protected readonly showGreeting: _angular_core.Signal<boolean>;
+    /** Starter questions on an empty thread (transports with `starterQuestions` only). */
+    protected readonly showStarters: _angular_core.Signal<boolean>;
+    constructor();
+    /** Pointer drag on the handle: the panel sits on the right, so moving left widens it. */
+    protected startResize(event: PointerEvent): void;
+    /** ←/→ resize (Shift: ×4), Home/End jump to min/max; the width is kept right away. */
+    protected onResizeKey(event: KeyboardEvent): void;
+    /** Double click on the handle: back to the default width, forgetting the kept one. */
+    protected resetWidth(): void;
+    private setWidth;
+    private clampWidth;
+    private measure;
+    protected onEscape(event: Event): void;
+    /** Shows the saved chats and reloads them. */
+    protected showSessions(): void;
+    protected backToChat(): void;
+    protected newChat(): void;
+    protected openSession(session: AssistantSessionSummary): Promise<void>;
+    protected askDelete(session: AssistantSessionSummary): void;
+    protected cancelDelete(): void;
+    protected confirmDelete(session: AssistantSessionSummary): Promise<void>;
+    protected sendStarter(question: string): void;
+    /** Locale date + time of a session, or '' when absent or unparsable. */
+    protected sessionDate(session: AssistantSessionSummary): string;
+    /** First chat of the list, else the back button. */
+    private focusSessionList;
+    private focusComposer;
+    /** Phone dialog: Tab and Shift+Tab cycle inside the panel. */
+    protected onTab(event: Event): void;
+    /** Drops a chip and keeps keyboard users in the row: next chip, else the composer. */
+    protected removeChip(id: string, index: number): void;
+    protected format(message: string, values: Record<string, string>): string;
+    protected onDecision(decision: AssistantProposalDecision): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssistantPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssistantPanelComponent, "mm-assistant-panel", never, { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "storageKey": { "alias": "storageKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Composer (ui-concept §5.3): multi-line, Enter sends, Shift+Enter is a newline,
+ * typing `/` at the start lists the slash commands (`ASSISTANT_SLASH_COMMANDS`, by default
+ * `/explain`, `/query`, `/summarise`, `/draft-pipeline`). The suggestion list follows the combobox
+ * pattern: focus stays in the textarea, ↑/↓ move, Enter/Tab pick, Esc closes the
+ * list (and only then lets Esc reach the panel).
+ *
+ * With {@link attachments} set (the transport accepts files, AB#5621) an "Attach file" button opens
+ * a file picker limited to `accept`; files are checked against `maxFiles` / `maxFileSizeBytes`,
+ * rejected ones are announced in an alert, attached ones are listed with a remove button, and a
+ * message may then be sent without text. Without it there is no attachment UI.
+ */
+declare class AssistantComposerComponent {
+    /** The composer text (two-way). */
+    readonly text: _angular_core.ModelSignal<string>;
+    /** Whether Enter may send; false while the transport is not ready. */
+    readonly canSend: _angular_core.InputSignal<boolean>;
+    /** A turn is running: the send button becomes a stop button. */
+    readonly sending: _angular_core.InputSignal<boolean>;
+    /** Accepted attachments; `null` (default) = no attachment UI. */
+    readonly attachments: _angular_core.InputSignal<AssistantAttachmentOptions | null>;
+    /** The attached files (two-way); sent with the next message by the host. */
+    readonly files: _angular_core.ModelSignal<readonly File[]>;
+    readonly send: _angular_core.OutputEmitterRef<string>;
+    readonly stop: _angular_core.OutputEmitterRef<void>;
+    /** Translations; members left out fall back to {@link ASSISTANT_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<AssistantMessages> | null>;
+    protected readonly m: _angular_core.Signal<AssistantMessages>;
+    private readonly textarea;
+    private readonly fileInput;
+    /** Messages about rejected files of the last pick. */
+    protected readonly attachmentErrors: _angular_core.WritableSignal<readonly string[]>;
+    /** Something to send: text, or (with attachments) at least one file. */
+    protected readonly hasContent: _angular_core.Signal<boolean>;
+    protected readonly multiple: _angular_core.Signal<boolean>;
+    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly paperclipIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly commands: readonly AssistantSlashCommand[];
+    protected readonly listId: string;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    private readonly dismissedFor;
+    /** Slash commands matching what was typed, while the text is a bare `/word`. */
+    protected readonly suggestions: _angular_core.Signal<readonly AssistantSlashCommand[]>;
+    protected readonly activeOptionId: _angular_core.Signal<string | null>;
+    /** Focuses the textarea with the caret at the end (entry points prefill it). */
+    focus(): void;
+    protected onInput(value: string): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected pick(command: AssistantSlashCommand): void;
+    protected submit(): void;
+    protected openFilePicker(): void;
+    protected onFilesPicked(input: HTMLInputElement): void;
+    protected removeFile(index: number): void;
+    protected format(message: string, values: Record<string, string>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssistantComposerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssistantComposerComponent, "mm-assistant-composer", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "canSend": { "alias": "canSend"; "required": false; "isSignal": true; }; "sending": { "alias": "sending"; "required": false; "isSignal": true; }; "attachments": { "alias": "attachments"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "text": "textChange"; "files": "filesChange"; "send": "send"; "stop": "stop"; }, never, never, true, never>;
+}
+
+/**
+ * The conversation (wireframe screen 6): user turns, assistant turns (markdown
+ * via `renderAssistantMarkdown`: no images, safe links only; violet edge), tool-call rows and proposal cards. Tool calls
+ * render with the `ASSISTANT_TOOL_CALL_COMPONENT` (an OctoMesh host passes `mm-ai-tool-call` from
+ * `@meshmakers/octo-ai-console`, ui-concept §5.1 "do not rebuild"); proposals are emitted, never executed.
+ *
+ * A user turn sent through a slash command's `expand` (AB#5621) shows the expanded prompt with the
+ * typed command (`slashCommand`) as a small label above it.
+ *
+ * While an assistant turn streams it shows the OctoBot `thinking` with "Thinking…" (AB#3444);
+ * once the reply is complete the newest assistant turn keeps the OctoBot as a still frame. The
+ * figure is decorative — the text carries the meaning — and appears at most once in the thread.
+ *
+ * The list is an `aria-live` log; it is `aria-busy` while a turn streams so a
+ * screen reader announces finished messages instead of every token. Nothing
+ * inside it carries its own live role, so each addition is announced once.
+ */
+declare class AssistantThreadComponent {
+    private readonly host;
+    readonly items: _angular_core.InputSignal<AssistantThreadItem[]>;
+    readonly proposalDecision: _angular_core.OutputEmitterRef<AssistantProposalDecision>;
+    /** Translations; members left out fall back to {@link ASSISTANT_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<AssistantMessages> | null>;
+    protected readonly m: _angular_core.Signal<AssistantMessages>;
+    protected readonly toolCallComponent: _angular_core.Type<unknown>;
+    /** Id of the newest assistant turn: the only one that shows the resting OctoBot. */
+    protected readonly lastAssistantId: _angular_core.Signal<string | null>;
+    protected readonly streaming: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssistantThreadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssistantThreadComponent, "mm-assistant-thread", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "proposalDecision": "proposalDecision"; }, never, never, true, never>;
+}
+
+/**
+ * A write the assistant proposes (ui-concept §5.3/§5.6, wireframe screen 6):
+ * violet card with a parameter table and Run / Edit / Discard. The buttons only
+ * emit — the card never executes anything; the host forwards the decision.
+ */
+declare class AssistantProposalCardComponent {
+    readonly proposal: _angular_core.InputSignal<AssistantProposal>;
+    /** Set once the person ran or discarded the proposal; disables the buttons. */
+    readonly decision: _angular_core.InputSignal<AssistantProposalDecisionKind | null>;
+    readonly run: _angular_core.OutputEmitterRef<AssistantProposal>;
+    readonly edit: _angular_core.OutputEmitterRef<AssistantProposal>;
+    readonly discard: _angular_core.OutputEmitterRef<AssistantProposal>;
+    /** Translations; members left out fall back to {@link ASSISTANT_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<AssistantMessages> | null>;
+    protected readonly m: _angular_core.Signal<AssistantMessages>;
+    protected readonly cardLabel: _angular_core.Signal<string>;
+    protected readonly decisionLabel: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssistantProposalCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssistantProposalCardComponent, "mm-assistant-proposal-card", never, { "proposal": { "alias": "proposal"; "required": true; "isSignal": true; }; "decision": { "alias": "decision"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "run": "run"; "edit": "edit"; "discard": "discard"; }, never, never, true, never>;
+}
+
+export { AssistantComposerComponent, AssistantMarkdownPipe, AssistantPanelComponent, AssistantProposalCardComponent, AssistantThreadComponent, classifyAssistantHref, renderAssistantMarkdown };

package/types/meshmakers-shared-ui-command-palette.d.ts

@@ -0,0 +1,398 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+import { Observable } from 'rxjs';
+
+/**
+ * Result groups of the command palette, in the vocabulary of
+ * `docs/concepts/ui-concept-ai-os.md` §4.1. The group decides the section
+ * header a result is listed under and which typed prefix scopes to it.
+ */
+type PaletteGroup = 'recent' | 'page' | 'action' | 'entity' | 'board' | 'tenant' | 'ai';
+/** How a result is opened: Enter opens in place, Cmd/Ctrl+Enter in a new browser tab. */
+type PaletteRunMode = 'open' | 'newTab';
+/**
+ * What the palette does after a result or action ran. By default it closes;
+ * an outcome with `query` keeps it open and replaces the query (e.g. "Switch
+ * tenant…" re-scopes the palette to `/`).
+ */
+interface PaletteRunOutcome {
+    query: string;
+}
+type PaletteRunResult = PaletteRunOutcome | void;
+/** One entry of a result's actions sub-menu (opened with Tab). */
+interface PaletteAction {
+    id: string;
+    label: string;
+    /** Keyboard hint shown on the right, e.g. '↵'. */
+    hint?: string;
+    run(): Promise<PaletteRunResult>;
+}
+/** One row of the palette. Providers create them; the ranking orders them. */
+interface PaletteResult {
+    /** Unique and stable across searches (prefix it with the provider id). */
+    id: string;
+    group: PaletteGroup;
+    label: string;
+    /** Secondary text on the right, e.g. "Adapter · Online". */
+    description?: string;
+    /** Where the result lives, e.g. ['Integration'] — rendered "Integration ›". */
+    path?: string[];
+    /** Technical id rendered in mono type, e.g. an rtId or ckTypeId. */
+    typeHint?: string;
+    icon?: SVGIcon;
+    /** One-character text icon used when there is no SVG icon. */
+    glyph?: string;
+    /** Extra search terms (matched one tier below the label). */
+    keywords?: string[];
+    /** Key into the recents store; results with a key get the frecency boost. */
+    recentKey?: string;
+    /** Set by entity providers when the query was this result's exact id: ranks first. */
+    exactMatch?: boolean;
+    /**
+     * Extra ranking weight 0…1 on top of the frecency, e.g. 1 for a pinned board, so pinned
+     * and recently used rows lead their group (only orders within a match tier).
+     */
+    rankBoost?: number;
+    /** Keep this row after ranking even without a text match (e.g. the assistant fallback). */
+    alwaysShow?: boolean;
+    run(mode: PaletteRunMode): Promise<PaletteRunResult>;
+    /** Sub-menu opened with Tab. */
+    actions?: PaletteAction[];
+}
+/** A parsed palette query: an optional scope from a typed prefix plus the search text. */
+interface PaletteQuery {
+    /** The input exactly as typed. */
+    raw: string;
+    /** The prefix character when one was typed ('>', '@', '#', '/', '?'). */
+    prefix: string | null;
+    /** The group the prefix scopes to, or null for an unscoped search. */
+    scope: PaletteGroup | null;
+    /** The search text without the prefix, trimmed. */
+    text: string;
+}
+/**
+ * One async result source. The palette calls `search` for every query
+ * change; a new query unsubscribes the previous search (cancellation), and a
+ * provider with `debounceMs` is only asked once typing paused that long.
+ * A provider error drops that provider's rows only.
+ */
+interface PaletteProvider {
+    /** Stable id, used to prefix result ids. */
+    readonly id: string;
+    /** Groups this provider produces; a scoped query skips providers without that group. */
+    readonly groups: readonly PaletteGroup[];
+    /** Remote providers debounce (§4.2: 150 ms); local ones answer immediately. */
+    readonly debounceMs?: number;
+    search(query: PaletteQuery): Observable<PaletteResult[]>;
+    /** Called whenever the palette opens: drop per-session caches (visibility gates, pages). */
+    reset?(): void;
+}
+/** Multi-provider token for the palette sources: `{ provide: PALETTE_PROVIDERS, useClass: MyProvider, multi: true }`. */
+declare const PALETTE_PROVIDERS: InjectionToken<PaletteProvider[]>;
+/**
+ * Where the palette reads the frecency of recently used results (the boost for rows with a
+ * `recentKey`). Optional: without a source every frecency is 0. Read once per palette session.
+ *
+ * ```ts
+ * { provide: PALETTE_RECENT_ITEMS_SOURCE, useFactory: () => {
+ *     const recents = inject(RecentItemsService);
+ *     return { frecencies: now => new Map(recents.items(now).map(i => [i.key, normalizedFrecency(i, now)])) };
+ * } }
+ * ```
+ */
+interface PaletteRecentItemsSource {
+    /** Normalised frecency 0…1 per `recentKey` at `now` (ms since epoch). */
+    frecencies(now: number): ReadonlyMap<string, number>;
+}
+declare const PALETTE_RECENT_ITEMS_SOURCE: InjectionToken<PaletteRecentItemsSource>;
+
+/**
+ * UI strings of the command palette (`mm-command-palette`) and of
+ * {@link PaletteNavigationService}'s clipboard notifications.
+ *
+ * Provide translations app wide with {@link COMMAND_PALETTE_MESSAGES} or per instance with the
+ * component's `messages` input (wins over the token). Missing, `undefined` or `null` members keep
+ * the English default of {@link DEFAULT_COMMAND_PALETTE_MESSAGES}; `{name}` placeholders are
+ * filled with {@link formatCommandPaletteMessage}.
+ */
+interface CommandPaletteMessages {
+    /** `aria-label` of the dialog. */
+    dialogLabel: string;
+    /** `aria-label` of the search input. */
+    inputLabel: string;
+    placeholder: string;
+    /** Close button on phones. */
+    cancel: string;
+    /** `aria-label` of the result list. */
+    results: string;
+    /** `aria-label` of the actions sub-menu; `{label}` = result label. */
+    actionsFor: string;
+    /** Header of the actions sub-menu; `{label}` = result label. */
+    actionsHeader: string;
+    /** Tooltip of the Tab hint on rows with actions. */
+    tabForActions: string;
+    /** Live status with one result. */
+    oneResult: string;
+    /** Live status; `{count}` = number of results. */
+    manyResults: string;
+    /** Empty list with a search text; `{text}` = search text. */
+    noResultsFor: string;
+    /** Empty list without a search text. */
+    typeToSearch: string;
+    footerMove: string;
+    footerOpen: string;
+    footerNewTab: string;
+    footerActions: string;
+    prefixActions: string;
+    prefixEntities: string;
+    prefixBoards: string;
+    prefixTenants: string;
+    groupRecent: string;
+    groupPage: string;
+    groupAction: string;
+    groupEntity: string;
+    groupBoard: string;
+    groupTenant: string;
+    groupAi: string;
+    /** `{label}` = what was copied, e.g. "RtId". */
+    copied: string;
+    copyFailed: string;
+}
+declare const DEFAULT_COMMAND_PALETTE_MESSAGES: CommandPaletteMessages;
+/** App-wide translations of the command palette (partial). */
+declare const COMMAND_PALETTE_MESSAGES: InjectionToken<Partial<CommandPaletteMessages>>;
+/** Merges overrides over {@link DEFAULT_COMMAND_PALETTE_MESSAGES}, later sources winning; null/undefined members are ignored. */
+declare function resolveCommandPaletteMessages(...overrides: (Partial<CommandPaletteMessages> | null | undefined)[]): CommandPaletteMessages;
+/** Replaces `{name}` placeholders; unknown placeholders stay as they are. */
+declare function formatCommandPaletteMessage(message: string, values: Record<string, string | number>): string;
+/** The group header of a result group. */
+declare function paletteGroupLabel(group: PaletteGroup, messages: CommandPaletteMessages): string;
+
+/** A request to show the palette with a query; a new object per call so effects re-run. */
+interface PaletteOpenRequest {
+    query: string;
+}
+/**
+ * Opens and closes the command palette (Cmd/Ctrl+K). The host (AppComponent) renders
+ * the overlay and binds the global hotkey; anything else — the top bar's
+ * "Search ⌘K" trigger, a Home tile, an empty state — calls {@link open}.
+ *
+ * Focus returns to the element that had it when the palette opened.
+ */
+declare class CommandPaletteService {
+    private readonly _isOpen;
+    private readonly _request;
+    private returnFocusTo;
+    /** Whether the palette is shown. */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    /** The latest open request; the palette adopts its query (also while already open). */
+    readonly request: _angular_core.Signal<PaletteOpenRequest>;
+    /**
+     * Shows the palette. `initialQuery` pre-fills the input, e.g. `'>'` for
+     * actions or `'/'` for the tenant list. Calling it while open replaces the query.
+     */
+    open(initialQuery?: string): void;
+    /** Hides the palette and gives focus back to where it was. */
+    close(): void;
+    /** Opens when closed, closes when open. */
+    toggle(initialQuery?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandPaletteService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CommandPaletteService>;
+}
+/** What a global keydown should do to the palette. */
+type PaletteHotkeyAction = 'toggle' | 'open';
+/**
+ * Maps a document keydown to a palette action (ui-concept §4.3):
+ *
+ * - Cmd+K (macOS) / Ctrl+K toggles — except inside a Monaco code editor,
+ *   whose own Cmd+K chords (comment, format …) must keep working;
+ * - `/` opens when no text field, text role, grid or Kendo widget is focused;
+ * - everything else, and events another handler already consumed, is ignored.
+ */
+declare function paletteHotkeyAction(event: KeyboardEvent, isOpen: boolean): PaletteHotkeyAction | null;
+
+/**
+ * Navigation and clipboard helpers shared by the palette providers. All
+ * palette targets are absolute router URLs (`/<tenant>/…`), so a result
+ * behaves the same whichever page the palette was opened on.
+ */
+declare class PaletteNavigationService {
+    private readonly router;
+    private readonly notifications;
+    private readonly messages;
+    /** The tenant of the current URL (first path segment), or null outside a tenant. */
+    currentTenantId(): string | null;
+    /**
+     * Turns a command link into an absolute URL: links starting with `/` are
+     * absolute already, all others are relative to the tenant (as the drawer
+     * resolves them via `navigateRelativeToRoute`).
+     */
+    tenantUrl(link: string): string;
+    /** Opens an absolute router URL in place or in a new browser tab. */
+    open(url: string, mode?: PaletteRunMode): Promise<void>;
+    /** Opens an external link (href) in a new tab, as the drawer does. */
+    openExternal(href: string, target?: string): void;
+    /** Copies a value and confirms it with a short notification. */
+    copy(value: string, label: string): Promise<void>;
+    private toHref;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaletteNavigationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PaletteNavigationService>;
+}
+
+/** Typed prefixes that force a group (ui-concept §4.2 rule 4). */
+declare const PALETTE_PREFIXES: Readonly<Record<string, PaletteGroup>>;
+/**
+ * Splits the raw input into an optional scope and the search text:
+ * `"> theme"` → scope `action`, text `theme`; `"edge"` → no scope.
+ * Only the first non-blank character counts as a prefix.
+ */
+declare function parsePaletteQuery(raw: string): PaletteQuery;
+/** A runtime id: 24 hex characters (MongoDB ObjectId). */
+declare function isRtId(text: string): boolean;
+
+/**
+ * Runs every provider for every query and merges their rows.
+ *
+ * - A provider whose groups do not include the query's scope is skipped (its rows clear at once).
+ * - A new query cancels the provider's running search (`switchMap` unsubscribes).
+ * - Providers with `debounceMs` start only after the query stood still that long; until
+ *   then their previous rows stay, so remote results do not flicker away while typing
+ *   (the ranking drops rows that no longer match).
+ * - An error drops only that provider's rows.
+ *
+ * The output emits on every provider answer, so local rows show immediately
+ * and remote rows stream in.
+ */
+declare function searchProviders(providers: readonly PaletteProvider[], query$: Observable<PaletteQuery>): Observable<PaletteResult[]>;
+
+/** Match tiers: prefix > word-start > subsequence (ui-concept §4.2 rule 2). */
+declare enum MatchTier {
+    None = 0,
+    Fuzzy = 1,
+    WordStart = 2,
+    Prefix = 3
+}
+/** How well `text` matches `query` (both compared case-insensitively). */
+declare function matchTier(text: string | null | undefined, query: string): MatchTier;
+/**
+ * Score of one result for a query: 0 means "does not match". `frecency` is
+ * the normalised (0…1) frecency of the result's recent key.
+ */
+declare function scoreResult(result: PaletteResult, text: string, frecency?: number): number;
+/** A section of the ranked palette list. */
+interface RankedGroup {
+    group: PaletteGroup;
+    results: PaletteResult[];
+}
+/**
+ * Orders the rows of all providers into sections. Pure: the same input gives
+ * the same output, so the palette can re-rank whenever a provider streams in
+ * without the list jumping around for unchanged rows.
+ *
+ * - non-matching rows are dropped (except `alwaysShow`),
+ * - rows sort by score within their group, ties by label,
+ * - groups follow the short/long query order; a group holding an exact id match goes first,
+ * - the assistant row (group `ai`) always stays last.
+ */
+declare function rankResults(results: readonly PaletteResult[], query: PaletteQuery, frecencyOf?: (key: string) => number): RankedGroup[];
+/** Splits a label into plain and highlighted parts for the first case-insensitive occurrence of `text`. */
+declare function highlightSegments(label: string, text: string): {
+    text: string;
+    match: boolean;
+}[];
+/**
+ * Keeps what the user already sees in place while results stream in for the
+ * SAME query (ui-concept §4.2 rule 5): groups already shown keep their
+ * position and new groups are appended below them (the assistant row stays
+ * last); inside a group, rows already shown keep their order and late rows
+ * are appended. Rows a provider no longer returns disappear. For a new query
+ * the fresh ranking is used as is.
+ */
+declare function stabilizeRanking(previous: readonly RankedGroup[], next: readonly RankedGroup[]): RankedGroup[];
+
+interface PaletteRow {
+    index: number;
+    result: PaletteResult;
+    segments: {
+        text: string;
+        match: boolean;
+    }[];
+    side: string;
+}
+interface PaletteSection {
+    group: PaletteGroup;
+    label: string;
+    rows: PaletteRow[];
+}
+/**
+ * The command palette overlay (Cmd/Ctrl+K, ui-concept §4). Render it only while
+ * {@link CommandPaletteService.isOpen} — one component instance is one palette session:
+ *
+ * ```html
+ * @if (commandPalette.isOpen()) { <mm-command-palette /> }
+ * ```
+ *
+ * Results come from the {@link PALETTE_PROVIDERS}; the frecency boost from the optional
+ * {@link PALETTE_RECENT_ITEMS_SOURCE}.
+ *
+ * Accessibility: modal dialog; the input is a combobox driving a listbox via
+ * `aria-activedescendant`, so focus never leaves the input (Tab is taken for
+ * the actions sub-menu, which keeps keyboard focus trapped in the dialog);
+ * focus goes back to the invoking element on close (the service does that).
+ */
+declare class CommandPaletteComponent implements OnInit {
+    private readonly palette;
+    private readonly providers;
+    private readonly recents;
+    /** Translations; members left out fall back to {@link COMMAND_PALETTE_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<CommandPaletteMessages> | null>;
+    protected readonly m: _angular_core.Signal<CommandPaletteMessages>;
+    private readonly destroyRef;
+    private readonly input;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly query$;
+    private readonly ranked;
+    private readonly parsed;
+    private readonly results;
+    /** Id of the highlighted row; null means "the first row" (reset whenever the user types). */
+    private readonly activeId;
+    protected readonly activeIndex: _angular_core.Signal<number>;
+    /** The result whose actions sub-menu is open (Tab), or null. */
+    protected readonly actionsFor: _angular_core.WritableSignal<PaletteResult | null>;
+    protected readonly activeActionIndex: _angular_core.WritableSignal<number>;
+    protected readonly sections: _angular_core.Signal<PaletteSection[]>;
+    protected readonly activeDescendant: _angular_core.Signal<string | null>;
+    /** Whether a listbox with options is shown (bound to the combobox's aria-expanded). */
+    protected readonly expanded: _angular_core.Signal<boolean>;
+    protected readonly statusText: _angular_core.Signal<string>;
+    protected readonly emptyText: _angular_core.Signal<string>;
+    protected get modifierLabel(): string;
+    constructor();
+    ngOnInit(): void;
+    protected groupLabel(group: PaletteGroup): string;
+    protected format(message: string, values: Record<string, string>): string;
+    protected onInput(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Clicks on the dialog's chrome (header, footer, group headers) must not take focus from the input. */
+    protected onDialogMouseDown(event: MouseEvent): void;
+    protected close(): void;
+    protected onScrimMouseDown(event: MouseEvent): void;
+    protected onOptionHover(result: PaletteResult): void;
+    protected onOptionClick(result: PaletteResult, event: MouseEvent): void;
+    /** Runs a result. The palette closes first; an outcome with a query reopens it with that query. */
+    protected execute(result: PaletteResult, mode: PaletteRunMode): Promise<void>;
+    protected runAction(action: PaletteAction): Promise<void>;
+    private finish;
+    private openActions;
+    private move;
+    private moveTo;
+    private setQuery;
+    private focusInput;
+    private scrollActiveIntoView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandPaletteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandPaletteComponent, "mm-command-palette", never, { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { COMMAND_PALETTE_MESSAGES, CommandPaletteComponent, CommandPaletteService, DEFAULT_COMMAND_PALETTE_MESSAGES, MatchTier, PALETTE_PREFIXES, PALETTE_PROVIDERS, PALETTE_RECENT_ITEMS_SOURCE, PaletteNavigationService, formatCommandPaletteMessage, highlightSegments, isRtId, matchTier, paletteGroupLabel, paletteHotkeyAction, parsePaletteQuery, rankResults, resolveCommandPaletteMessages, scoreResult, searchProviders, stabilizeRanking };
+export type { CommandPaletteMessages, PaletteAction, PaletteGroup, PaletteHotkeyAction, PaletteOpenRequest, PaletteProvider, PaletteQuery, PaletteRecentItemsSource, PaletteResult, PaletteRunMode, PaletteRunOutcome, PaletteRunResult, RankedGroup };