@devaccel-labs/app-comments-toolbar 1.1.0 → 1.3.0

package/dist/types/runtime/debug-context-core.d.ts

@@ -0,0 +1,88 @@
+/**
+ * What every platform's debug context capture shares, with no DOM and no React Native: errors folded into
+ * counts, failed, slow and pending requests, the console's ordinary lines, going offline or to the
+ * background, what the host knows, the cache and stores, and turning all of it into the file. The web page
+ * (`./debug-context.ts`) and native apps (`@devaccel-labs/app-comments-native`) feed it from their own hooks.
+ *
+ * The hot path (`requestStarted`, `consoleCall`) does bookkeeping only. Reading a body, reading headers and
+ * redacting happen for failed or slow requests, after the app already has its answer.
+ */
+import { type DebugContextFile, type DebugErrorKind, type DebugSignal, type LifecycleEvent, type ResolvedDebugContext } from "./debug-context-model.js";
+import { type RedactionTally } from "./debug-context-redact.js";
+import type { ReplayEvent } from "./replay-model.js";
+export declare const EXCERPT_CHARS = 2048;
+export declare const BODY_CHARS = 16384;
+export declare const GRAPHQL_READ_CHARS = 65536;
+/** Frames from browser extensions and from the toolbar itself. */
+export declare const FOREIGN_FRAME: RegExp;
+/** Response types whose text is worth an excerpt. */
+export declare const TEXTUAL: RegExp;
+export type DebugCaptureStats = {
+    calls: number;
+    ms: number;
+};
+export declare function errorOf(value: unknown): {
+    message: string;
+    stack?: string;
+};
+/** A console call's arguments as one line, with the stack of an `Error` among them. */
+export declare function argText(args: readonly unknown[]): {
+    message: string;
+    stack?: string;
+};
+/** An excerpt with JSON keys that look sensitive masked; other text scrubbed as text. */
+export declare function excerptOf(text: string, max: number, tally: RedactionTally): string;
+export declare function graphqlErrors(text: string, tally: RedactionTally): string[];
+export declare function within<T>(promise: Promise<T> | T, ms: number): Promise<T | undefined>;
+/**
+ * Replaces `host[key]` and returns the restore. The restore puts the original back only while ours is still
+ * installed, so a patch someone added after ours (Sentry, another tool) is never removed.
+ */
+export declare function patch<T extends object, K extends keyof T>(host: T, key: K, next: T[K]): () => void;
+/** How a platform reads a finished request: headers now, text only when asked (and only once). */
+export type RequestReaders = {
+    header: (name: string) => string | null;
+    /** The response's text, up to `max` characters. */
+    text?: (max: number) => Promise<string | null>;
+    /** The request's body as the app passed it. Only a string is ever kept. */
+    requestBody?: unknown;
+    /** The text could be read for a successful GraphQL request too (a 200 that holds errors). */
+    graphqlReadable?: boolean;
+};
+export type DebugCoreEnv = {
+    /** The address relative URLs are read against and same-origin URLs are shortened to. */
+    pageUrl: () => string | undefined;
+    /** Requests that are the toolbar's own (the comment service): never recorded. */
+    ignoreUrl?: (url: string) => boolean;
+    /** A high-resolution clock for `stats`. Default `Date.now`. */
+    clock?: () => number;
+};
+/** What every platform's file says the same way. */
+export type CoreSnapshot = Pick<DebugContextFile, "errors" | "logs" | "network" | "lifecycle" | "steps" | "queries" | "stores" | "realtime" | "identity" | "flags" | "extra" | "build"> & {
+    join: Pick<DebugContextFile["join"], "traceId" | "sessionId" | "requestIds">;
+    routePattern?: string;
+};
+export declare function createDebugCore(resolved: ResolvedDebugContext, env: DebugCoreEnv): {
+    signals: Record<DebugSignal, boolean>;
+    options: import("./debug-context-model.js").DebugContextOptions;
+    tally: RedactionTally;
+    timed: <T>(task: () => T) => T;
+    pushError: (kind: DebugErrorKind, level: "error" | "warn", rawMessage: string, stack?: string, source?: string, componentStack?: string[]) => void;
+    consoleCall: (level: "error" | "warn" | "log" | "info" | "debug", args: readonly unknown[]) => void;
+    requestStarted: (method: string, url: string) => number | null;
+    requestFinished: (id: number, status: number, readers: RequestReaders) => void;
+    requestAborted: (id: number) => void;
+    noteLifecycle: (event: LifecycleEvent) => void;
+    reportError: (error: unknown, componentStack?: string | null) => void;
+    shared: (reportAt: number, steps: readonly ReplayEvent[] | undefined, fileTally: RedactionTally, toolbarBuild?: string) => Promise<CoreSnapshot>;
+    finish: (file: DebugContextFile, fileTally: RedactionTally) => DebugContextFile | null;
+    skeletonFile: (reportAt: number, platform: DebugContextFile["platform"]) => DebugContextFile;
+    readonly stopped: boolean;
+    mark(): void;
+    /** The report's moment: the mark, or now. Clears the mark. */
+    takeMark(): number;
+    clearMark(): void;
+    stats: () => DebugCaptureStats;
+    stop(): void;
+};
+export type DebugCore = ReturnType<typeof createDebugCore>;

package/dist/types/runtime/debug-context-host.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What a host app calls beside `debugContext`: report an error its error boundary caught, and summarise a
+ * TanStack Query cache. Tiny and free of toolbar code, so the npm package and the script tag can both carry it.
+ * The toolbar itself is loaded from the service, so the two talk through one window event.
+ */
+import type { QuerySummary } from "./debug-context-model.js";
+export declare const DEBUG_ERROR_EVENT = "comment-tool:error";
+export type DebugErrorDetail = {
+    error: unknown;
+    componentStack: string | null;
+};
+/**
+ * Hands an error an error boundary caught to the toolbar's debug context (the `componentStacks` signal), with
+ * React's component stack. Does nothing when the toolbar is not running or the signal is off.
+ *
+ *   <ErrorBoundary onError={(error, info) => reportToolbarError(error, info.componentStack)}>
+ */
+export declare function reportToolbarError(error: unknown, componentStack?: string | null): void;
+/** The part of a TanStack Query `QueryClient` this reads. */
+export type QueryCacheLike = {
+    getQueryCache(): {
+        getAll(): ReadonlyArray<{
+            queryKey: unknown;
+            state: {
+                status?: string;
+                fetchStatus?: string;
+                error?: unknown;
+                dataUpdatedAt?: number;
+            };
+            getObserversCount?: () => number;
+        }>;
+    };
+};
+/**
+ * `debugContext.queries` for a TanStack Query client: each query's key and state, never its data.
+ *
+ *   debugContext={{ signals: { queries: true }, queries: () => queryCacheSummary(queryClient) }}
+ */
+export declare function queryCacheSummary(client: QueryCacheLike, max?: number): QuerySummary[];

package/dist/types/runtime/debug-context-model.d.ts

@@ -0,0 +1,352 @@
+/**
+ * The debug context file (`context-<stamp>.json`): what a ticket carries for whoever fixes the bug, a person or
+ * a coding agent. DOM-free, so the web toolbar, native clients, the service's second redaction pass and the
+ * console all use the same shape, the same limits and the same brief.
+ *
+ * Every section is optional: a host turns each signal on or off in code (`DebugContextOptions`), and a reader
+ * says "not captured" rather than "nothing happened".
+ */
+import { type JsonBag } from "./debug-context-redact.js";
+export declare const DEBUG_CONTEXT_PREFIX = "context-";
+/** The most a context file may weigh once serialized. Larger files are trimmed (`fitDebugContext`). */
+export declare const DEBUG_CONTEXT_MAX_BYTES: number;
+/** On whenever a host turns debug context on. */
+export declare const DEFAULT_SIGNALS: readonly ["errors", "network", "responseExcerpts", "steps", "environment", "page", "build", "target", "host", "resources", "lifecycle"];
+/** Off unless a host names them. */
+export declare const OPT_IN_SIGNALS: readonly ["staleBuild", "componentStacks", "domExcerpt", "queries", "realtime", "stores", "storeValues", "consoleLog", "performance", "storage", "bodies"];
+export type DebugSignal = (typeof DEFAULT_SIGNALS)[number] | (typeof OPT_IN_SIGNALS)[number];
+export declare const DEBUG_SIGNALS: readonly DebugSignal[];
+/**
+ * Who files the report. `reviewer`: people testing the app with the comment toolbar. `support`: the app's own
+ * customers through a help form, so failed-response excerpts start off.
+ */
+export type DebugAudience = "reviewer" | "support";
+export type FlagValue = string | number | boolean | null;
+/** The host app's build. `deployed` is the build the server serves now, for spotting a stale tab. */
+export type HostBuild = {
+    commit?: string;
+    version?: string;
+    env?: string;
+    builtAt?: string;
+    deployed?: string;
+};
+export type RealtimeState = {
+    status?: string;
+    /** Epoch ms of the last message received. */
+    lastMessageAt?: number;
+    reconnects?: number;
+    lastClose?: {
+        code?: number;
+        reason?: string;
+    };
+};
+/** What the host knows and the browser does not. Ids, never emails or names of people. */
+export type HostContext = {
+    user?: {
+        id?: string;
+        role?: string;
+        plan?: string;
+        locale?: string;
+    };
+    org?: {
+        id?: string;
+        name?: string;
+    };
+    flags?: Record<string, FlagValue>;
+    build?: HostBuild;
+    /** The id the host's backend logs carry for this page or request chain (`traceparent`'s trace id). */
+    traceId?: string;
+    sessionId?: string;
+    /** The router's pattern for the page, e.g. `/projects/:id`. */
+    routePattern?: string;
+    realtime?: RealtimeState;
+    /** A few more facts of the host's own, at most 20. */
+    extra?: Record<string, FlagValue>;
+};
+/** One query of a data-fetching cache (TanStack Query, SWR): its state, never its data. */
+export type QuerySummary = {
+    key: unknown;
+    status?: string;
+    fetchStatus?: string;
+    error?: unknown;
+    /** Epoch ms the data last changed. */
+    updatedAt?: number;
+    observers?: number;
+};
+/** How a host turns debug context on and what it allows. All of it is code, in the host app. */
+export type DebugContextOptions = {
+    /** Default true once an options object is given. */
+    enabled?: boolean;
+    /** Default `reviewer` in the toolbar. */
+    audience?: DebugAudience;
+    /** Turns single signals on or off; anything not named keeps its default (`DEFAULT_SIGNALS`). */
+    signals?: Partial<Record<DebugSignal, boolean>>;
+    /** Static build facts. `getContext().build` wins field by field. */
+    build?: HostBuild;
+    /** Asked once per report, with a 300 ms limit. */
+    getContext?: () => HostContext | Promise<HostContext>;
+    /** The last word before the file leaves the browser: change it, or return null to send none. */
+    beforeCapture?: (file: DebugContextFile) => DebugContextFile | null;
+    /** Told the report's id, so the host can log it beside its own trace. */
+    onReport?: (reportId: string) => void;
+    /** Read for the `queries` signal. */
+    queries?: () => readonly QuerySummary[];
+    /** Read for the `stores` signal, by name. */
+    stores?: Record<string, () => unknown>;
+    /** More response headers that carry request ids. */
+    idHeaders?: readonly string[];
+    /** Requests whose full bodies are kept (the `bodies` signal): URL prefixes or patterns. */
+    bodyUrls?: readonly (string | RegExp)[];
+    /** `localStorage`/`sessionStorage` keys whose values are kept (the `storage` signal). Others: names only. */
+    storageValueKeys?: readonly string[];
+    /** A request slower than this is kept as slow. Default 3000. */
+    slowMs?: number;
+};
+/** `true`, `false`, or the options. Off when absent. */
+export type DebugContextConfig = boolean | DebugContextOptions;
+export type ResolvedDebugContext = {
+    audience: DebugAudience;
+    signals: Record<DebugSignal, boolean>;
+    options: DebugContextOptions;
+    slowMs: number;
+};
+/** The host's config as one shape, or null when debug context is off. */
+export declare function resolveDebugContext(config: DebugContextConfig | null | undefined, fallbackAudience?: DebugAudience): ResolvedDebugContext | null;
+/**
+ * What, of a host's config, decides what is captured: a capture restarts only when this changes. Functions
+ * are left out; they are read live (`liveDebugOptions`).
+ */
+export declare function debugContextKey(config: DebugContextConfig | null | undefined): string;
+/**
+ * The options as they are now, with every function reading `read()` when it is called: a host that passes a
+ * new options object on every render keeps one running capture that still calls its latest functions.
+ */
+export declare function liveDebugOptions(read: () => DebugContextConfig | null | undefined): DebugContextOptions;
+export type DebugErrorKind = "uncaught" | "rejection" | "console" | "boundary" | "resource" | "csp" | "reported";
+export type DebugError = {
+    /** Milliseconds before the report (negative). */
+    t: number;
+    kind: DebugErrorKind;
+    level: "error" | "warn";
+    message: string;
+    stack?: string[];
+    /** `file:line:col` where the browser said it happened. */
+    source?: string;
+    componentStack?: string[];
+    count: number;
+};
+export type DebugRequest = {
+    t: number;
+    method: string;
+    url: string;
+    /** 0 when there was no answer. */
+    status: number;
+    ms?: number;
+    bytes?: number;
+    contentType?: string;
+    excerpt?: string;
+    graphql?: {
+        operation?: string;
+        errors: string[];
+    };
+    ids?: Record<string, string>;
+    requestBody?: string;
+    responseBody?: string;
+};
+export type DebugStep = {
+    t: number;
+    type: "navigate";
+    path: string;
+} | {
+    t: number;
+    type: "click";
+    label: string;
+} | {
+    t: number;
+    type: "input";
+    label: string;
+    redacted: boolean;
+    value?: string;
+} | {
+    t: number;
+    type: "console";
+    level: "error" | "warn";
+    message: string;
+} | {
+    t: number;
+    type: "network";
+    method: string;
+    path: string;
+    status: number;
+} | {
+    t: number;
+    type: "say";
+    text: string;
+};
+export type LifecycleEvent = "online" | "offline" | "hidden" | "visible" | "foreground" | "background";
+export type DebugContextFile = {
+    v: 1;
+    kind: "debug-context";
+    capturedAt: string;
+    audience: DebugAudience;
+    platform: "web" | "ios" | "android";
+    page?: {
+        url: string;
+        route: string;
+        routePattern?: string;
+        title?: string;
+        referrer?: string;
+        loadedAgoMs?: number;
+        softNavigations?: number;
+        visibility?: string;
+    };
+    build?: {
+        host?: HostBuild;
+        toolbar?: string;
+        staleHost?: boolean;
+    };
+    client?: {
+        browser?: string;
+        os?: string;
+        device?: string;
+        viewport?: [number, number];
+        dpr?: number;
+        zoom?: number;
+        locale?: string;
+        timezone?: string;
+        colorScheme?: string;
+        reducedMotion?: boolean;
+        online?: boolean;
+        connection?: string;
+        touch?: boolean;
+        appVersion?: string;
+        appBuild?: string;
+        appVariant?: string;
+    };
+    identity?: {
+        userId?: string;
+        role?: string;
+        plan?: string;
+        locale?: string;
+        orgId?: string;
+        orgName?: string;
+    };
+    flags?: Record<string, FlagValue>;
+    extra?: Record<string, FlagValue>;
+    target?: {
+        component?: string;
+        file?: string;
+        stack?: string[];
+        role?: string;
+        name?: string;
+        tag?: string;
+        html?: string;
+        box?: [number, number, number, number];
+        styles?: Record<string, string>;
+    };
+    errors?: DebugError[];
+    logs?: {
+        t: number;
+        level: string;
+        message: string;
+    }[];
+    network?: {
+        failed: DebugRequest[];
+        slow: DebugRequest[];
+        pending: DebugRequest[];
+        aborted: number;
+    };
+    steps?: DebugStep[];
+    lifecycle?: {
+        t: number;
+        event: LifecycleEvent;
+    }[];
+    performance?: {
+        longTasks?: number;
+        longestTaskMs?: number;
+        inpMs?: number;
+        lcpMs?: number;
+        cls?: number;
+        loadMs?: number;
+        heapMb?: number;
+    };
+    queries?: {
+        key: string;
+        status?: string;
+        fetchStatus?: string;
+        error?: string;
+        updatedAgoMs?: number;
+        observers?: number;
+    }[];
+    stores?: JsonBag;
+    storage?: {
+        local?: {
+            key: string;
+            bytes: number;
+            value?: string;
+        }[];
+        session?: {
+            key: string;
+            bytes: number;
+            value?: string;
+        }[];
+        cookies?: string[];
+        indexedDb?: string[];
+    };
+    realtime?: {
+        status?: string;
+        lastMessageAgoMs?: number;
+        reconnects?: number;
+        lastClose?: {
+            code?: number;
+            reason?: string;
+        };
+    };
+    join: {
+        reportId: string;
+        traceId?: string;
+        sessionId?: string;
+        requestIds?: string[];
+    };
+    /** Which signals were on, so a reader can tell "off" from "nothing happened". */
+    signals: DebugSignal[];
+    redaction: {
+        rules: 1;
+        masked: number;
+        dropped: number;
+        truncated: boolean;
+    };
+};
+export declare function isDebugContextName(name: string): boolean;
+/** `context-<stamp>.json` for a report taken at `at`. */
+export declare function debugContextName(at?: Date): string;
+/** A report id: sortable by time, unguessable, safe in a header or a log line. */
+export declare function newReportId(now?: number): string;
+/**
+ * A context file rebuilt from untrusted JSON: only known fields, every string redacted again, every list and
+ * string bounded. Null when it is not a context file. Running it on its own output changes nothing but the
+ * counts, so the browser, the service and the console can all run it.
+ */
+export declare function sanitizeDebugContext(value: unknown): DebugContextFile | null;
+export declare function debugContextBytes(file: DebugContextFile): number;
+/**
+ * The file cut down to `maxBytes`, dropping the least useful parts first: store state, storage, the cache,
+ * logs, bodies, then the oldest steps, excerpts and stacks. Marks `redaction.truncated` when anything went.
+ */
+export declare function fitDebugContext(file: DebugContextFile, maxBytes?: number): DebugContextFile;
+export type BriefMeta = {
+    title?: string | null;
+    body?: string | null;
+    author?: string | null;
+    kind?: string | null;
+    createdAt?: string | null;
+    threadUrl?: string | null;
+    /** Other files on the thread, by name, so the brief can point at them. */
+    files?: readonly string[];
+};
+/**
+ * The context as a short markdown brief for a coding agent: what was reported, where to look, what broke
+ * (newest first), the steps, the environment, and what else exists. The first three sections are always
+ * there, saying so when they are empty. Kept under about 6,000 tokens.
+ */
+export declare function debugContextBrief(file: DebugContextFile, meta?: BriefMeta): string;

package/dist/types/runtime/debug-context-redact.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Redaction for the debug context file. DOM-free: the toolbar runs it in the browser before upload, the
+ * service runs it again on every stored file, and native clients share it.
+ *
+ * Over-redact rather than under-redact. Every rule here is applied to text an app wrote (console lines, error
+ * messages, response excerpts, store values), so it has to catch secrets and personal data nobody labelled.
+ */
+/** A JSON object whose keys are not known ahead: store state, parsed bodies. Values are redacted before use. */
+export type JsonBag = {
+    [key: string]: unknown;
+};
+/** Counts what was taken out, so a reader knows something is missing instead of assuming it never happened. */
+export type RedactionTally = {
+    masked: number;
+    dropped: number;
+};
+export declare function newTally(): RedactionTally;
+/**
+ * `value` with secrets and personal data replaced, control characters removed and cut at `max`. Placeholders
+ * (`[secret]`, `[email]`, …) are stable, so running it twice changes nothing.
+ */
+export declare function scrubText(value: string, max: number, tally?: RedactionTally): string;
+/** Object keys whose values are never kept, at any depth. */
+export declare const SENSITIVE_KEY: RegExp;
+/**
+ * A URL with its userinfo removed, secret-looking query values replaced and the rest scrubbed as text. Same-
+ * origin URLs keep only path and query. Unparseable input is scrubbed as text.
+ */
+export declare function scrubUrl(value: string, max: number, base?: string, tally?: RedactionTally): string;
+export type ScrubOptions = {
+    /** Deepest level kept; anything below becomes "[…]". */
+    depth?: number;
+    /** Longest string kept. */
+    text?: number;
+    /** Most entries kept per object or array. */
+    entries?: number;
+    /** Keep only the shape: types and sizes, no values. */
+    shapeOnly?: boolean;
+    tally?: RedactionTally;
+};
+/** Any JSON-like value, redacted at every depth: sensitive keys dropped, strings scrubbed, sizes bounded. */
+export declare function scrubValue(value: unknown, options?: ScrubOptions, level?: number): unknown;
+/** Response headers whose values are ids that join a request with backend logs. Values are opaque. */
+export declare const ID_HEADERS: readonly string[];
+/** The id headers to read: the defaults plus a host's own, lowercased, invalid names dropped. */
+export declare function idHeaderNames(extra?: readonly string[]): string[];
+/** An id header's value: opaque, so only control characters and obvious secrets are removed. */
+export declare function scrubId(value: string): string;

package/dist/types/runtime/debug-context.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Debug context on a web page: the hooks (console, `error`, `unhandledrejection`, fetch, XHR, resources,
+ * CSP, online, visibility, performance) that feed the shared core (`./debug-context-core.ts`), and what
+ * only a page has: its address, the browser, the element pointed at, storage.
+ *
+ * Runs only while someone is signed in to the toolbar and the host turned debug context on in code. Nothing
+ * leaves the page until a report is posted.
+ */
+import type { Anchor } from "../core/index.js";
+import { type DebugCaptureStats } from "./debug-context-core.js";
+import type { DebugContextFile, ResolvedDebugContext } from "./debug-context-model.js";
+import type { ReplayEvent } from "./replay-model.js";
+export type { DebugCaptureStats } from "./debug-context-core.js";
+export type DebugSnapshotInput = {
+    element?: Element | null;
+    anchor?: Anchor | null;
+    /** The toolbar's step trail (its replay buffer), oldest first. */
+    steps?: readonly ReplayEvent[];
+};
+export type DebugCapture = {
+    /** The moment the person started the report: the file's clock and the "still pending" list come from it. */
+    mark(): void;
+    /** The file, redacted and bounded, or null when the host's `beforeCapture` refused it or threw. */
+    snapshot(input?: DebugSnapshotInput): Promise<DebugContextFile | null>;
+    /** An error the host's error boundary caught (`componentStacks`). */
+    reportError(error: unknown, componentStack?: string | null): void;
+    /** Time spent in this module's hooks, for measuring the hot path. */
+    stats(): DebugCaptureStats;
+    stop(): void;
+};
+export type DebugCaptureEnv = {
+    /** Requests that are the toolbar's own (the comment service): never recorded. */
+    ignoreUrl?: (url: string) => boolean;
+    window?: Window & typeof globalThis;
+};
+export declare function startDebugContext(resolved: ResolvedDebugContext, env?: DebugCaptureEnv): DebugCapture;

package/dist/types/runtime/details-model.d.ts

@@ -0,0 +1,7 @@
+/** Role and custom field values on a comment: what is turned on, and what a post sends. DOM-free. */
+import type { Details, Settings } from "./api.js";
+export declare const noDetails: Details;
+export declare function detailsEnabled(settings: Settings | null): boolean;
+export declare function hasFieldValues(details: Details): boolean;
+/** Only sends what is turned on, so a disabled feature never rejects a post. */
+export declare function detailsPayload(settings: Settings | null, details: Details): Partial<Details>;

package/dist/types/runtime/details.d.ts

@@ -1,16 +1,18 @@
 import { type KeyboardEvent as ReactKeyboardEvent } from "react";
 import type { Details, FieldValue, Settings, Thread } from "./client.js";
-export declare const noDetails: Details;
-export declare function detailsEnabled(settings: Settings | null): boolean;
-export declare function hasFieldValues(details: Details): boolean;
-/** Only sends what is turned on, so a disabled feature never rejects a post. */
-export declare function detailsPayload(settings: Settings | null, details: Details): Partial<Details>;
+import { type ReportKind } from "./kind-model.js";
+export { detailsEnabled, detailsPayload, hasFieldValues, noDetails } from "./details-model.js";
 export declare function DetailsInput({ settings, value, onChange, onKeyDown, }: {
     settings: Settings | null;
     value: Details;
     onChange: (next: Details) => void;
     onKeyDown?: (event: ReactKeyboardEvent<HTMLTextAreaElement>) => void;
 }): import("react/jsx-runtime").JSX.Element | null;
+/** A new comment's kind, if the person wants to say; pressing the chosen one again leaves it to the service. */
+export declare function KindInput({ value, onChange, }: {
+    value: ReportKind | null;
+    onChange: (next: ReportKind | null) => void;
+}): import("react/jsx-runtime").JSX.Element;
 export declare function RoleBadge({ role }: {
     role: string | null;
 }): import("react/jsx-runtime").JSX.Element | null;