@infotrust/ui 0.0.0-stage → 0.30.1

package/dist/components/charts/ItTrendChart.vue.d.ts

@@ -0,0 +1,80 @@
+import { type ItChartDate, type ItChartSeries, type ItValueFormatter } from './chart';
+export interface ItTrendPoint {
+    x: ItChartDate;
+    /** `null` leaves a gap in the line (no scan that day). */
+    y: number | null;
+}
+export interface ItTrendSeries extends ItChartSeries {
+    points: ItTrendPoint[];
+}
+export interface ItChartAnnotation {
+    /** The date of the event (a vertical marker). */
+    x: ItChartDate;
+    /** End date: shades the span from `x` to `x2` instead of a single line. */
+    x2?: ItChartDate;
+    /** Short text: "Scan rules changed". */
+    label: string;
+}
+type __VLS_Props = {
+    series: ItTrendSeries[];
+    /** What is plotted, with its period: "Open findings, last 30 days". Starts the accessible summary and names the table. */
+    label: string;
+    /** Replaces the generated accessible summary. */
+    summary?: string;
+    /** The smallest total height in px, including the date axis. The chart grows to fill a taller panel. */
+    height?: number;
+    /** Area wash under the lines. Defaults to on for a single series. */
+    area?: boolean;
+    annotations?: ItChartAnnotation[];
+    /** Noun after values in the readout: "findings". */
+    unit?: string;
+    /** Value formatter (readout, table, end label). Defaults to formatCount. */
+    formatValue?: ItValueFormatter;
+    /** Date formatter for ticks, readout, and table. Defaults to formatDate ("Oct 9"). */
+    formatX?: (time: number) => string;
+    /** Skeleton on first load; on refetch the previous render dims instead. */
+    loading?: boolean;
+    /** The data did not load: a danger callout in place of the chart (a string says why). Retry with a `@retry` listener; `#error` replaces it. */
+    error?: string | boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** Keys of hidden series (`v-model:hidden`). The legend toggles them. */
+    hidden?: string[];
+    /** `table` shows the data table in place of the plot. */
+    view?: 'chart' | 'table';
+};
+declare var __VLS_1: {
+    message: string;
+    retry: () => void;
+};
+type __VLS_Slots = {} & {
+    error?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+    "update:hidden": (keys: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+    "onUpdate:hidden"?: ((keys: string[]) => any) | undefined;
+}>, {
+    area: boolean;
+    summary: string;
+    error: string | boolean;
+    height: number;
+    view: "chart" | "table";
+    loading: boolean;
+    unit: string;
+    hidden: string[];
+    emptyTitle: string;
+    emptyDescription: string;
+    annotations: ItChartAnnotation[];
+    formatValue: ItValueFormatter;
+    formatX: (time: number) => string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/chart.d.ts

@@ -0,0 +1,84 @@
+import { type Ref } from 'vue';
+/** Status tones a series may wear when it *means* a state (critical, passed). */
+export type ItChartTone = 'danger' | 'warning' | 'info' | 'success' | 'neutral';
+/**
+ * One series (or stacked segment) in a chart. Color follows the series'
+ * position in its array (`--it-color-chart-1…6`, in order) unless `tone`
+ * maps it onto a status color. Hiding a series never repaints the others.
+ */
+export interface ItChartSeries {
+    key: string;
+    label: string;
+    /** Use only when the series means a state (severity, pass/fail). Never mix tones and categorical series in one chart. */
+    tone?: ItChartTone;
+}
+/** Number of categorical slots in the token set. */
+export declare const CHART_SLOTS = 6;
+/**
+ * CSS color for a series: the status solid for a tone, otherwise the
+ * categorical slot for its index. Slots are never cycled or generated; past
+ * the sixth series every extra series shares slot 6 (fold the tail into an
+ * "Other" series instead).
+ */
+export declare function chartColor(index: number, tone?: ItChartTone): string;
+/** The single-series fill: slot 1 by default, or a status tone. */
+export declare function singleColor(tone?: ItChartTone | 'default'): string;
+/**
+ * A "nice" step near `rough`: 1, 2, 2.5, or 5 times a power of ten. With
+ * `integer`, steps stay whole numbers (counts never get a 2.5 tick).
+ */
+export declare function niceStep(rough: number, integer?: boolean): number;
+/**
+ * Evenly spaced round ticks that cover [min, max] with about `count`
+ * intervals. The first tick is ≤ min and the last ≥ max, so the domain of a
+ * chart is `[ticks[0], ticks.at(-1)]`. An empty or flat range gets one step.
+ */
+export declare function niceTicks(min: number, max: number, count?: number, integer?: boolean): number[];
+/** Maps a domain onto a range linearly. A zero-width domain maps to the range start. */
+export declare function scaleLinear(domain: [number, number], range: [number, number]): (value: number) => number;
+/**
+ * Indices of the x labels to show: `max` of them, the first and the last
+ * included, spread evenly between, so the last label sits as far from its
+ * neighbour as every other pair does.
+ */
+export declare function tickIndices(count: number, max: number): number[];
+/** Nearest index in a sorted list of positions. */
+export declare function nearestIndex(positions: number[], target: number): number;
+/** Approximate rendered width of a 13px Poppins label, for reserving axis room. */
+export declare function textWidth(text: string): number;
+export type ItChartDate = Date | string | number;
+/**
+ * Milliseconds for a chart x value. A bare `YYYY-MM-DD` string is a local
+ * calendar day (not UTC midnight), so "2026-10-01" never renders as Sep 30.
+ */
+export declare function toTime(value: ItChartDate): number;
+/** Default x formatter: `formatDate` ("Oct 9"). */
+export declare function formatChartDate(time: number): string;
+export type ItValueFormatter = (value: number) => string;
+export declare const defaultFormat: ItValueFormatter;
+/** "412 findings" or "412" when there is no unit. */
+export declare function withUnit(text: string, unit?: string): string;
+/** First and last finite values of a list, or null when it has none. */
+export declare function endpoints(values: Array<number | null | undefined>): {
+    first: number;
+    last: number;
+} | null;
+/** "1,284 → 1,012" for a series, or "no data". */
+export declare function trendPhrase(values: Array<number | null | undefined>, format?: ItValueFormatter): string;
+export declare function sum(values: Array<number | null | undefined>): number;
+/** Share of a total as a whole percent ("12%"); totals of zero give "0%". */
+export declare function sharePercent(value: number, total: number): string;
+/** --it-duration-slow on `el`, in ms (250 when the token is not loaded). The browser may report it in seconds (".25s"). */
+export declare function slowMs(el: Element | null | undefined): number;
+/**
+ * Whether the page lays out, so a zero width means the chart is not shown
+ * (display: none, a hidden tab). A DOM without layout (a test DOM) reads
+ * every width as zero; there a draw-in never waits to be shown.
+ */
+export declare function pageLaysOut(): boolean;
+/**
+ * Whether prefers-reduced-motion is on, kept current when the setting
+ * changes (as the CSS motion rules are). Call it in a component's setup; the
+ * listener goes when the component unmounts.
+ */
+export declare function useReducedMotion(): Readonly<Ref<boolean>>;

package/dist/components/charts/selection.d.ts

@@ -0,0 +1,14 @@
+/** Shared controlled toggle semantics for bar and donut drill-down. */
+export declare function useChartSelection(props: {
+    selectable?: boolean;
+    selected?: readonly string[];
+}): {
+    isSelected: (item: {
+        key: string;
+    }) => boolean;
+    pressed: (item: {
+        key: string;
+    }) => "true" | "false" | undefined;
+};
+/** Arrow keys and Home / End share the bar chart's bounded navigation. */
+export declare function chartStep(key: string, current: number, last: number): number | null;

package/dist/components/charts/skeleton.d.ts

@@ -0,0 +1,16 @@
+/** Horizontal bars, largest first: the shape `sort="value"` gives. */
+export declare const SKELETON_BAR_WIDTHS: string[];
+/** Horizontal bars in their given order. */
+export declare const SKELETON_BAR_WIDTHS_UNSORTED: string[];
+/** Category labels: short names of different lengths, in px. */
+export declare const SKELETON_LABEL_WIDTHS: number[];
+/** Vertical columns, as a share of the plot height: the Suite's uneven trend placeholder. */
+export declare const SKELETON_COLUMN_HEIGHTS: number[];
+/** Grid lines from the top of the plot, in percent; the last is the baseline. */
+export declare const SKELETON_GRID: number[];
+/** Rows a skeleton draws: the data's own count when the app already knows it, else `fallback`. */
+export declare function skeletonCount(known: number, fallback: number, max: number): number;
+/** `clip-path` for a line of `thickness` px along the wave, at any plot size. */
+export declare function skeletonLineClip(thickness?: number): string;
+/** `clip-path` for the area under the wave, down to the baseline. */
+export declare function skeletonAreaClip(): string;

package/dist/components/command/ItAssistantPanel.vue.d.ts

@@ -0,0 +1,56 @@
+import type { ItAssistantSession } from './assistant-session';
+import { type ItAssistantAction, type ItAssistantStarter } from './command';
+type __VLS_Props = {
+    session: ItAssistantSession;
+    title?: string;
+    /** A line under the title: what the assistant can do here, or what it is doing now. */
+    status?: string;
+    /** Shown, with the starters, while the thread is empty. */
+    intro?: string;
+    starters?: readonly ItAssistantStarter[];
+    placeholder?: string;
+    /** Show Close (emits `close`). */
+    closable?: boolean;
+    /** Follows a link inside the app. */
+    navigate?: (href: string) => void;
+};
+type __VLS_Slots = {
+    /** Controls in the header, before New thread (an app's "Undo the assistant's changes"). */
+    actions?: () => unknown;
+    attachment?: (scope: {
+        attachment: unknown;
+    }) => unknown;
+    action?: (scope: {
+        action: ItAssistantAction;
+        review: () => void;
+    }) => unknown;
+    error?: (scope: {
+        message: string;
+        details: unknown;
+        retry: () => void;
+    }) => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    review: (action: ItAssistantAction) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onReview?: ((action: ItAssistantAction) => any) | undefined;
+}>, {
+    title: string;
+    placeholder: string;
+    status: string;
+    closable: boolean;
+    navigate: (href: string) => void;
+    starters: readonly ItAssistantStarter[];
+    intro: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/command/ItAssistantThread.vue.d.ts

@@ -0,0 +1,73 @@
+import { type ItAssistantAction } from './command';
+export interface ItThreadTool {
+    id: string;
+    label: string;
+    state: 'running' | 'done' | 'error';
+    detail?: string;
+}
+export interface ItThreadMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    text: string;
+    tools: ItThreadTool[];
+    attachments: unknown[];
+    action?: ItAssistantAction;
+    /** What went wrong, said so the person can act. */
+    error?: string;
+    /** The app's own detail for the error (an error id, a request): the `error` slot gets it. */
+    errorDetails?: unknown;
+    /** The reply has finished arriving. */
+    done: boolean;
+    /** The person stopped the reply: it ends where it was, marked "Stopped". */
+    stopped?: boolean;
+}
+type __VLS_Props = {
+    messages: readonly ItThreadMessage[];
+    /** A reply is on its way: the send button stops it. */
+    busy: boolean;
+    placeholder?: string;
+    /** Follows a link inside the app. */
+    navigate?: (href: string) => void;
+};
+type __VLS_Slots = {
+    /** Something a reply carries beyond text (a label graph, a chart). */
+    attachment?: (scope: {
+        attachment: unknown;
+    }) => unknown;
+    /** Replaces the draft card. */
+    action?: (scope: {
+        action: ItAssistantAction;
+        review: () => void;
+    }) => unknown;
+    /** Replaces the error callout: the app's own error view, with its details and a way to try again. */
+    error?: (scope: {
+        message: string;
+        details: unknown;
+        retry: () => void;
+    }) => unknown;
+};
+/** The palette moves focus here when the thread opens. */
+declare function focus(): void;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    focus: typeof focus;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    stop: () => any;
+    review: (action: ItAssistantAction) => any;
+    send: (text: string) => any;
+    retry: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onStop?: (() => any) | undefined;
+    onReview?: ((action: ItAssistantAction) => any) | undefined;
+    onSend?: ((text: string) => any) | undefined;
+    onRetry?: (() => any) | undefined;
+}>, {
+    placeholder: string;
+    navigate: (href: string) => void;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/command/ItCommandPalette.vue.d.ts

@@ -0,0 +1,102 @@
+import { type ItAssistantSession } from './assistant-session';
+import { type ItAssistantAction, type ItAssistantClient, type ItAssistantStarter, type ItCommandItem, type ItCommandSource } from './command';
+type __VLS_Props = {
+    visible: boolean;
+    /** What search looks in, one section each, in this order. */
+    sources: readonly ItCommandSource[];
+    /** "Jump to" places shown with an empty query. */
+    jumpTo?: readonly ItCommandItem[];
+    /** "Ask the assistant" starters shown with an empty query. */
+    starters?: readonly ItAssistantStarter[];
+    /** The app's assistant. Without it (and without `session`) the palette searches only. */
+    assistant?: ItAssistantClient | null;
+    /**
+     * The app's conversation (createItAssistantSession), when it shows the
+     * same conversation elsewhere too, such as a panel docked beside a canvas.
+     * Without it the palette keeps its own, with `assistant`.
+     */
+    session?: ItAssistantSession | null;
+    /** The assistant's name in the thread header: "Assistant". */
+    assistantName?: string;
+    /** The footer's credit: "Powered by the Suite assistant". */
+    poweredBy?: string;
+    placeholder?: string;
+    /** The thread's message box placeholder. */
+    askPlaceholder?: string;
+    /** The review view's title (with the `review` region): "Review draft". */
+    reviewTitle?: string;
+    /** Prevent review exit while saving. */
+    reviewBusy?: boolean;
+    /** Return false to keep the edited draft. Rejections also keep it open. */
+    beforeReviewLeave?: (reason: 'back' | 'close') => boolean | Promise<boolean>;
+    /** Milliseconds a remote source waits after typing. */
+    debounce?: number;
+};
+/** What the review regions get: the draft, the way back to the conversation, and `done` (new thread, then close). */
+interface ReviewScope {
+    action: ItAssistantAction;
+    back: () => void;
+    done: () => void;
+}
+type __VLS_Slots = {
+    /** Something a reply carries beyond text. */
+    attachment?: (scope: {
+        attachment: unknown;
+    }) => unknown;
+    /** Replaces the "Ready for review" card. */
+    action?: (scope: {
+        action: ItAssistantAction;
+        review: () => void;
+    }) => unknown;
+    /** Replaces a failed reply's callout: the app's error view, with its details and a way to try again. */
+    error?: (scope: {
+        message: string;
+        details: unknown;
+        retry: () => void;
+    }) => unknown;
+    /** The app's review of a draft, inside the palette. With it, Review opens this view. */
+    review?: (scope: ReviewScope) => unknown;
+    /** Controls in the review view's header, before Close (Undo, Save). */
+    'review-actions'?: (scope: ReviewScope) => unknown;
+    /** A failed search source, independent of assistant errors. */
+    'source-error'?: (scope: {
+        source: ItCommandSource;
+        error: unknown;
+        retry: () => void;
+    }) => unknown;
+};
+/** Starts over: stops a reply, empties the thread, and gives the next question a new conversation id. */
+declare function newThread(): void;
+declare function backToSearch(): Promise<void>;
+declare function close(): Promise<void>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    newThread: typeof newThread;
+    showSearch: typeof backToSearch;
+    requestClose: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (item: ItCommandItem) => any;
+    "update:visible": (visible: boolean) => any;
+    review: (action: ItAssistantAction) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((item: ItCommandItem) => any) | undefined;
+    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+    onReview?: ((action: ItAssistantAction) => any) | undefined;
+}>, {
+    placeholder: string;
+    debounce: number;
+    assistant: ItAssistantClient | null;
+    jumpTo: readonly ItCommandItem[];
+    starters: readonly ItAssistantStarter[];
+    session: ItAssistantSession | null;
+    assistantName: string;
+    poweredBy: string;
+    askPlaceholder: string;
+    reviewTitle: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/command/ItMarkdown.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    source: string;
+    /** The text is still arriving: draw code plain. */
+    streaming?: boolean;
+    /** Follows a link inside the app ("/rules/RI-1N93"). Without it, the browser follows it. */
+    navigate?: (href: string) => void;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    navigate: (href: string) => void;
+    streaming: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/command/assistant-session.d.ts

@@ -0,0 +1,26 @@
+import { type Ref } from 'vue';
+import type { ItThreadMessage } from './ItAssistantThread.vue';
+import type { ItAssistantClient } from './command';
+export interface ItAssistantSession {
+    /** The conversation, oldest first. Replace it, never mutate it. */
+    readonly messages: Ref<ItThreadMessage[]>;
+    /** A reply is on its way. */
+    readonly busy: Ref<boolean>;
+    /** Characters each reply has typed out: the thread keeps its place when it remounts. */
+    readonly shown: Ref<Record<string, number>>;
+    /** The id that keys the conversation on the server; New thread changes it. */
+    readonly conversationId: Ref<string>;
+    /** Asks the next question (ignored while a reply is on its way). */
+    send(text: string): Promise<void>;
+    /** Ends the reply at once: the composer is free, and whatever the client still sends is dropped. */
+    stop(): void;
+    /** Tries the last question again: drops the failed reply, every bubble of it, and asks once more. */
+    retry(): void;
+    /** Starts over: stops a reply, empties the thread, and gives the next question a new conversation id. */
+    newThread(): void;
+}
+type ClientSource = ItAssistantClient | null | undefined | (() => ItAssistantClient | null | undefined);
+export declare function newItConversationId(): string;
+/** A conversation with the app's assistant. Pass a function when the client can change (another organization). */
+export declare function createItAssistantSession(client: ClientSource): ItAssistantSession;
+export {};

package/dist/components/command/command.d.ts

@@ -0,0 +1,127 @@
+import type { Component, InjectionKey, Ref } from 'vue';
+import type { ItRouteLocation } from '../../utils/router';
+/** One result: a page, an asset, a rule, an org. Selecting it navigates (`to`, `href`) or runs (`run`). */
+export interface ItCommandItem {
+    id: string;
+    label: string;
+    /** One muted line under the label: what it is, where it lives. */
+    meta?: string;
+    /** A Lucide icon for the kind of item. */
+    icon?: Component;
+    /** A platform key: its ItPlatformLogo stands in for the icon. */
+    platform?: string;
+    /** The kind, in one word at the row's end: "Page", "Asset", "Rule". */
+    badge?: string;
+    /** A route (vue-router, an optional peer) to open. */
+    to?: ItRouteLocation;
+    /** A URL to open when there is no `to`. */
+    href?: string;
+    /** Runs instead of navigating (switch org, toggle a setting). */
+    run?: () => void | Promise<void>;
+}
+/** One group of results: a section with a heading. */
+export interface ItCommandSource {
+    key: string;
+    /** The section heading: "Pages", "Assets". */
+    label: string;
+    /** Most rows shown. Default 5. */
+    limit?: number;
+    /**
+     * A server search: the palette waits `debounce` ms after typing, shows
+     * skeleton rows while it runs, drops an answer to an older query, and stops
+     * asking once a query found nothing and the person keeps typing past it.
+     */
+    remote?: boolean;
+    /** Characters needed before this source searches. Default 1. */
+    minLength?: number;
+    search: (query: string, context: {
+        signal: AbortSignal;
+    }) => readonly ItCommandItem[] | Promise<readonly ItCommandItem[]>;
+}
+/** A starter shown under "Ask the assistant" when the query is empty. */
+export interface ItAssistantStarter {
+    label: string;
+    /** The question it asks. Shown as the row's meta. */
+    prompt: string;
+}
+/** A draft the assistant made, for the app to review and save (a rule, an audit, a label change). */
+export interface ItAssistantAction {
+    /** "Governance rule: Consent mode on EU containers". */
+    title: string;
+    /** Why, in one or two sentences. */
+    reasoning?: string;
+    /** The app's own payload. */
+    data?: unknown;
+}
+/**
+ * What a streaming assistant reports. An app maps its own stream (NDJSON, SSE) onto these.
+ *
+ * One answer can take several turns of the model (it reads, runs tools, reads
+ * again): `message` closes the current reply bubble and starts the next one,
+ * so each turn's steps sit above its own words. `text-set` replaces the
+ * current bubble's text, for a stream that sends a final, cleaned-up text.
+ * `error` may carry `details` for the app's own error view (the `error` slot).
+ */
+export type ItAssistantEvent = {
+    type: 'thinking';
+} | {
+    type: 'message';
+} | {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'text-set';
+    text: string;
+} | {
+    type: 'tool-start';
+    id: string;
+    label: string;
+} | {
+    type: 'tool-done';
+    id: string;
+    summary?: string;
+} | {
+    type: 'tool-error';
+    id: string;
+    error: string;
+} | {
+    type: 'attachment';
+    attachment: unknown;
+} | {
+    type: 'action';
+    action: ItAssistantAction;
+} | {
+    type: 'error';
+    message: string;
+    details?: unknown;
+};
+export interface ItAssistantMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+/** The app's assistant: it streams one answer, and may route an unclear query. */
+export interface ItAssistantClient {
+    /** Streams the answer to the last user message through `emit`. Resolve when it ends; honor `signal` (Stop, close). */
+    send(request: {
+        messages: ItAssistantMessage[];
+        conversationId: string;
+        signal: AbortSignal;
+    }, emit: (event: ItAssistantEvent) => void): Promise<void>;
+    /** A query the local rules cannot place: search or ask? (The Suite asks a small model, with a 4 s budget.) */
+    route?: (query: string, signal: AbortSignal) => Promise<'search' | 'ask'>;
+}
+export type ItQueryIntent = 'search' | 'ask' | 'ambiguous';
+/**
+ * Search or ask, from the words alone (no model, no cost): an id or two words
+ * is a search; a question, seven words, or "draft a …" is a question for the
+ * assistant; the rest is unclear (the app's `route` may decide it).
+ */
+export declare function itClassifyQuery(query: string): ItQueryIntent;
+/** Case-insensitive match on any of the words: "label" in "Labels" or its meta. */
+export declare function itMatchesQuery(query: string, ...texts: (string | undefined)[]): boolean;
+/**
+ * How much of each reply the thread has typed out, by message id. The palette
+ * provides it, so the count outlives the thread: a reopened palette shows a
+ * reply where the person left it instead of typing it again.
+ */
+export declare const IT_THREAD_SHOWN: InjectionKey<Ref<Record<string, number>>>;

package/dist/components/command/markdown.d.ts

@@ -0,0 +1,55 @@
+export type ItMdInline = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'strong';
+    children: ItMdInline[];
+} | {
+    type: 'em';
+    children: ItMdInline[];
+} | {
+    type: 'code';
+    text: string;
+} | {
+    type: 'link';
+    href: string;
+    children: ItMdInline[];
+};
+export type ItMdBlock = {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4;
+    children: ItMdInline[];
+} | {
+    type: 'paragraph';
+    children: ItMdInline[];
+} | {
+    type: 'list';
+    ordered: boolean;
+    start: number;
+    items: ItMdInline[][];
+} | {
+    type: 'quote';
+    children: ItMdBlock[];
+} | {
+    type: 'code';
+    language: string;
+    code: string;
+    closed: boolean;
+} | {
+    type: 'table';
+    head: ItMdInline[][];
+    rows: ItMdInline[][][];
+} | {
+    type: 'rule';
+};
+/** Links that may be followed: the web, mail, and paths inside the app. Anything else (javascript:, data:) stays text. */
+export declare function itSafeHref(href: string): string | null;
+export declare function itParseInline(text: string): ItMdInline[];
+export declare function itParseMarkdown(source: string): ItMdBlock[];
+/**
+ * itParseMarkdown for text that grows at its end (a streaming reply): each
+ * call reads again only from the last blocks, and returns the earlier blocks
+ * as the same objects, so their drawing can be kept. Any other change reads
+ * the whole text. The result always equals itParseMarkdown(source).
+ */
+export declare function itMarkdownReader(): (source: string) => ItMdBlock[];

package/dist/components/content/ItDocsArticle.vue.d.ts

@@ -0,0 +1,18 @@
+import type { ItDocsSection } from './docs';
+type __VLS_Props = {
+    sections: readonly ItDocsSection[];
+    loading?: boolean;
+    /** Names the zoom dialog when a screenshot has no alt text. */
+    imageLabel?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    navigate: (href: string, event: MouseEvent) => any;
+    "copy-link": (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNavigate?: ((href: string, event: MouseEvent) => any) | undefined;
+    "onCopy-link"?: ((id: string) => any) | undefined;
+}>, {
+    loading: boolean;
+    imageLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;