@zendir/ui 0.1.0

package/dist/react/core/ChatPanel.d.ts

@@ -0,0 +1,627 @@
+import { default as React } from 'react';
+import { StatusLevel } from '../utils';
+
+/** Status alert block — renders as a colored banner with icon shape */
+export interface ChatBlockAlert {
+    type: 'alert';
+    status: StatusLevel;
+    title: string;
+    detail?: string;
+}
+/** Telemetry readout block — key/value pairs with optional status per row */
+export interface ChatBlockTelemetry {
+    type: 'telemetry';
+    title?: string;
+    items: Array<{
+        label: string;
+        value: string | number;
+        unit?: string;
+        status?: StatusLevel;
+    }>;
+}
+/** Progress block — inline progress bar */
+export interface ChatBlockProgress {
+    type: 'progress';
+    label: string;
+    value: number;
+    max?: number;
+    status?: StatusLevel;
+}
+/** Data table block */
+export interface ChatBlockTable {
+    type: 'table';
+    title?: string;
+    columns: string[];
+    rows: (string | number)[][];
+}
+/** Action buttons block */
+export interface ChatBlockActions {
+    type: 'actions';
+    buttons: Array<{
+        label: string;
+        variant?: 'primary' | 'secondary' | 'critical';
+        onClick: () => void;
+    }>;
+}
+/** Choice/option selector — AI presents options, user picks one (or multiple) */
+export interface ChatBlockChoice {
+    type: 'choice';
+    /** Unique ID for this choice block (used in onBlockEvent callback) */
+    id: string;
+    title?: string;
+    /** Allow multiple selections */
+    multiple?: boolean;
+    options: Array<{
+        id: string;
+        label: string;
+        description?: string;
+        status?: StatusLevel;
+        disabled?: boolean;
+    }>;
+    /** Pre-selected option IDs */
+    selected?: string[];
+    /** Has the user already submitted their choice? */
+    submitted?: boolean;
+}
+/** Confirmation gate — requires explicit operator acknowledgment before proceeding */
+export interface ChatBlockConfirm {
+    type: 'confirm';
+    /** Unique ID for this confirm block (used in onBlockEvent callback) */
+    id: string;
+    status?: StatusLevel;
+    title: string;
+    detail?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    /** Has the operator already responded? */
+    resolved?: 'confirmed' | 'cancelled';
+}
+/** Command block — displays a command with copy-to-clipboard and optional execute */
+export interface ChatBlockCommand {
+    type: 'command';
+    /** Unique ID for this command block (used in onBlockEvent callback) */
+    id?: string;
+    language?: string;
+    command: string;
+    label?: string;
+    /** Show an execute button (fires onBlockEvent with action:'execute') */
+    executable?: boolean;
+}
+/** Key-value metadata block — compact pairs for context/metadata */
+export interface ChatBlockKV {
+    type: 'kv';
+    title?: string;
+    pairs: Array<{
+        key: string;
+        value: string | number;
+        mono?: boolean;
+    }>;
+}
+export type ChatBlock = ChatBlockAlert | ChatBlockTelemetry | ChatBlockProgress | ChatBlockTable | ChatBlockActions | ChatBlockChoice | ChatBlockConfirm | ChatBlockCommand | ChatBlockKV;
+/** Event emitted by interactive blocks (choice, confirm, command) */
+export interface ChatBlockEvent {
+    /** The block ID */
+    blockId: string;
+    /** The message ID containing this block */
+    messageId: string;
+    /** Action type */
+    action: 'select' | 'confirm' | 'cancel' | 'execute' | 'copy';
+    /** Payload (selected option IDs for choice, command string for execute/copy) */
+    value?: string | string[];
+}
+export interface ChatMessage {
+    /** Unique message ID */
+    id: string;
+    /** Message content (supports markdown-like formatting) */
+    content: string;
+    /** Sender role */
+    role: 'user' | 'assistant' | 'system';
+    /** Timestamp (ms) */
+    timestamp?: number;
+    /** Message delivery status */
+    status?: 'sending' | 'sent' | 'error';
+    /** Astro UX severity — colors the message accent (system messages default to this) */
+    severity?: StatusLevel;
+    /** Structured blocks rendered below the text content */
+    blocks?: ChatBlock[];
+    /** Legacy: action buttons (prefer blocks with type:'actions') */
+    actions?: Array<{
+        label: string;
+        onClick: () => void;
+    }>;
+}
+export interface ChatPanelProps {
+    /** Array of messages */
+    messages: ChatMessage[];
+    /** Send handler */
+    onSend: (text: string) => void;
+    /** Is assistant currently generating */
+    loading?: boolean;
+    /** Input placeholder */
+    placeholder?: string;
+    /** Panel title */
+    title?: string;
+    /** Subtitle (e.g. model name) */
+    subtitle?: string;
+    /** Disable input */
+    disabled?: boolean;
+    /** Show timestamps */
+    showTimestamps?: boolean;
+    /** Height of the panel (default: 100%) */
+    height?: string | number;
+    /** Clear handler (shows clear button when provided) */
+    onClear?: () => void;
+    /** Handler for interactive block events (choice selection, confirm/cancel, command execute) */
+    onBlockEvent?: (event: ChatBlockEvent) => void;
+    /** Custom style */
+    style?: React.CSSProperties;
+}
+/**
+ * Supported response formats from the AI backend.
+ * - 'json':  Standard JSON (default). Most compatible.
+ * - 'yaml':  YAML compact format. ~30-40% fewer tokens than JSON for identical data.
+ * - 'auto':  Auto-detect (tries JSON first, then YAML, then plain text).
+ */
+export type ChatResponseFormat = 'json' | 'yaml' | 'auto';
+/** Shape of a parsed AI response (content + optional blocks + severity). */
+export interface ChatResponsePayload {
+    content: string;
+    severity?: StatusLevel;
+    blocks?: ChatBlock[];
+}
+/** Options for creating a customised response parser. */
+export interface ChatResponseParserOptions {
+    /**
+     * Custom YAML parser function. Receives raw YAML text, returns a parsed object.
+     * If not provided, uses the built-in lightweight parser.
+     *
+     * For production, plug in `js-yaml` or `yaml`:
+     * ```ts
+     * import yaml from 'js-yaml';
+     * const parse = createChatResponseParser({ yamlParser: (s) => yaml.load(s) });
+     * ```
+     */
+    yamlParser?: (text: string) => unknown;
+    /** Default format when not specified per-call. Defaults to `'auto'`. */
+    defaultFormat?: ChatResponseFormat;
+    /** Custom message ID generator. Defaults to `crypto.randomUUID()`. */
+    idGenerator?: () => string;
+}
+/**
+ * Parse an AI response string into a `ChatMessage`.
+ *
+ * Supports three strategies (controlled by `format`):
+ * - **json**: Parse as JSON. Falls back to plain text on failure.
+ * - **yaml**: Parse as YAML (built-in lightweight parser). ~30-40% fewer tokens.
+ * - **auto** (default): Try JSON → YAML → plain text.
+ *
+ * All parsed blocks are sanitized to ensure required arrays exist, preventing
+ * runtime crashes from malformed AI output.
+ *
+ * ## Why YAML?
+ * For the same structured response, YAML uses ~30-40% fewer tokens:
+ * ```
+ * JSON (~180 tokens): {"content":"Battery low.","blocks":[{"type":"alert",...}]}
+ * YAML (~120 tokens): content: Battery low.\nblocks:\n  - type: alert\n    ...
+ * ```
+ *
+ * ## Tool/Function Calling (recommended for production)
+ * Pass `CHAT_RESPONSE_TOOL_SCHEMA` in your API call. The model is constrained
+ * at the decoding level — zero prompt tokens for the schema.
+ *
+ * ## Custom YAML parser
+ * Use `createChatResponseParser({ yamlParser })` to plug in `js-yaml` or `yaml`.
+ *
+ * @example
+ * ```ts
+ * const msg = parseChatResponse(aiOutput);              // auto-detect
+ * const msg = parseChatResponse(aiOutput, 'yaml');       // force YAML
+ * const msg = parseChatResponse(toolCallArgs, 'json');   // from function call
+ * ```
+ */
+export declare function parseChatResponse(raw: string, format?: ChatResponseFormat, options?: ChatResponseParserOptions): ChatMessage;
+/**
+ * Create a pre-configured response parser.
+ *
+ * Use this to set global defaults (format, YAML parser, ID generator) so you
+ * don't have to pass options on every call.
+ *
+ * @example
+ * ```ts
+ * import yaml from 'js-yaml';
+ * import { createChatResponseParser } from '@zendir/ui';
+ *
+ * // Create once at app init
+ * export const parseAI = createChatResponseParser({
+ *   yamlParser: (s) => yaml.load(s),
+ *   defaultFormat: 'yaml',
+ * });
+ *
+ * // Use everywhere
+ * const msg = parseAI(aiOutput);
+ * ```
+ */
+export declare function createChatResponseParser(options?: ChatResponseParserOptions): (raw: string, format?: ChatResponseFormat) => ChatMessage;
+/**
+ * Lightweight types for MCP tool results.
+ * These mirror the MCP specification without requiring the full SDK as a dependency.
+ * @see https://modelcontextprotocol.io/specification/2025-11-25
+ */
+/** A single content block in an MCP tool result. */
+export interface McpToolContent {
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    resource?: {
+        uri: string;
+        text?: string;
+        mimeType?: string;
+    };
+}
+/** MCP tool call result (matches `CallToolResult` from the spec). */
+export interface McpToolResult {
+    content: McpToolContent[];
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Convert an MCP tool call result into a `ChatMessage` with structured blocks.
+ *
+ * Handles three patterns automatically:
+ * 1. **Structured JSON/YAML** — Tool returns text matching `ChatResponsePayload` → parsed into typed blocks
+ * 2. **Plain text** — Rendered as a simple assistant message with tool metadata
+ * 3. **Error** — Rendered as a critical alert block
+ *
+ * This bridges the MCP protocol with ChatPanel's block rendering system, so any
+ * MCP server tool can produce rich operator UIs without custom rendering code.
+ *
+ * @example
+ * ```ts
+ * import { parseMcpToolResult } from '@zendir/ui/react';
+ *
+ * // With use-mcp hook
+ * const { callTool } = useMcp({ url: 'https://ops-server.example.com/mcp' });
+ * const result = await callTool('get_satellite_health', { id: 'SAT-001' });
+ * const msg = parseMcpToolResult('get_satellite_health', result);
+ * setMessages(prev => [...prev, msg]);
+ *
+ * // With @modelcontextprotocol/sdk
+ * const result = await mcpClient.callTool({ name: 'get_satellite_health', arguments: { id: 'SAT-001' } });
+ * const msg = parseMcpToolResult('get_satellite_health', result);
+ * ```
+ */
+export declare function parseMcpToolResult(toolName: string, result: McpToolResult, options?: {
+    idGenerator?: () => string;
+}): ChatMessage;
+/**
+ * MCP server tool definition for the `respond_to_operator` tool.
+ *
+ * Register this on your MCP server to enable structured ChatPanel responses.
+ * The schema is identical to `CHAT_RESPONSE_TOOL_SCHEMA` but formatted for the
+ * MCP `server.tool()` registration API.
+ *
+ * Compatible with: `@modelcontextprotocol/sdk`, any MCP server implementation.
+ *
+ * @example
+ * ```ts
+ * import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+ * import { CHAT_RESPONSE_MCP_TOOL } from '@zendir/ui';
+ *
+ * const server = new McpServer({ name: 'ops-assistant', version: '1.0.0' });
+ *
+ * server.tool(
+ *   CHAT_RESPONSE_MCP_TOOL.name,
+ *   CHAT_RESPONSE_MCP_TOOL.description,
+ *   CHAT_RESPONSE_MCP_TOOL.inputSchema,
+ *   async ({ content, severity, blocks }) => ({
+ *     content: [{ type: 'text', text: JSON.stringify({ content, severity, blocks }) }],
+ *   })
+ * );
+ * ```
+ */
+export declare const CHAT_RESPONSE_MCP_TOOL: {
+    readonly name: "respond_to_operator";
+    readonly description: "Respond to the spacecraft operator with text content and optional structured UI blocks (alerts, telemetry, progress, tables, choices, confirmations, commands, key-value metadata). Use the Astro UX 6-level status system: normal, standby, caution, serious, critical, off.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["content"];
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "Plain-text or markdown response shown to the operator.";
+            };
+            readonly severity: {
+                readonly type: "string";
+                readonly enum: readonly ["normal", "standby", "caution", "serious", "critical", "off"];
+            };
+            readonly blocks: {
+                readonly type: "array";
+                readonly description: "Structured UI blocks rendered below the text content.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type"];
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly enum: readonly ["alert", "telemetry", "progress", "table", "choice", "confirm", "command", "kv"];
+                        };
+                        readonly status: {
+                            readonly type: "string";
+                            readonly enum: readonly ["normal", "standby", "caution", "serious", "critical", "off"];
+                        };
+                        readonly title: {
+                            readonly type: "string";
+                        };
+                        readonly detail: {
+                            readonly type: "string";
+                        };
+                        readonly label: {
+                            readonly type: "string";
+                        };
+                        readonly value: {
+                            readonly type: "number";
+                        };
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly command: {
+                            readonly type: "string";
+                        };
+                        readonly executable: {
+                            readonly type: "boolean";
+                        };
+                        readonly items: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly label: {
+                                        readonly type: "string";
+                                    };
+                                    readonly value: {};
+                                    readonly unit: {
+                                        readonly type: "string";
+                                    };
+                                    readonly status: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                        readonly columns: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly rows: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "array";
+                            };
+                        };
+                        readonly options: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly label: {
+                                        readonly type: "string";
+                                    };
+                                    readonly description: {
+                                        readonly type: "string";
+                                    };
+                                    readonly status: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                        readonly pairs: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly type: "string";
+                                    };
+                                    readonly value: {};
+                                    readonly mono: {
+                                        readonly type: "boolean";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * OpenAI-compatible function/tool schema for structured chat responses.
+ *
+ * Pass this as a tool definition in your API call. The model is constrained
+ * to emit valid JSON matching this schema — no prompt engineering required.
+ *
+ * Works with: OpenAI (Structured Outputs / function calling), Anthropic (Tool Use),
+ * Google Gemini (Function Calling), Mistral, Cohere, and any OpenAI-compatible API.
+ *
+ * @example
+ * ```ts
+ * // OpenAI
+ * tools: [{ type: 'function', function: CHAT_RESPONSE_TOOL_SCHEMA }]
+ *
+ * // Anthropic
+ * tools: [{ name: CHAT_RESPONSE_TOOL_SCHEMA.name,
+ *           description: CHAT_RESPONSE_TOOL_SCHEMA.description,
+ *           input_schema: CHAT_RESPONSE_TOOL_SCHEMA.parameters }]
+ *
+ * // Google Gemini
+ * tools: [{ functionDeclarations: [CHAT_RESPONSE_TOOL_SCHEMA] }]
+ * ```
+ */
+export declare const CHAT_RESPONSE_TOOL_SCHEMA: {
+    readonly name: "respond_to_operator";
+    readonly description: "Respond to the spacecraft operator with text content and optional structured UI blocks (alerts, telemetry, progress, tables, choices, confirmations, commands, key-value metadata). Use the Astro UX 6-level status system: normal, standby, caution, serious, critical, off.";
+    readonly parameters: {
+        readonly type: "object";
+        readonly required: readonly ["content"];
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "Plain-text or markdown response shown to the operator.";
+            };
+            readonly severity: {
+                readonly type: "string";
+                readonly enum: readonly ["normal", "standby", "caution", "serious", "critical", "off"];
+                readonly description: "Overall message severity. Drives the accent color and icon.";
+            };
+            readonly blocks: {
+                readonly type: "array";
+                readonly description: "Structured UI blocks rendered below the text content.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type"];
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly enum: readonly ["alert", "telemetry", "progress", "table", "choice", "confirm", "command", "kv"];
+                        };
+                        readonly status: {
+                            readonly type: "string";
+                            readonly enum: readonly ["normal", "standby", "caution", "serious", "critical", "off"];
+                        };
+                        readonly title: {
+                            readonly type: "string";
+                        };
+                        readonly detail: {
+                            readonly type: "string";
+                        };
+                        readonly items: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly label: {
+                                        readonly type: "string";
+                                    };
+                                    readonly value: {};
+                                    readonly unit: {
+                                        readonly type: "string";
+                                    };
+                                    readonly status: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["normal", "standby", "caution", "serious", "critical", "off"];
+                                    };
+                                };
+                            };
+                        };
+                        readonly label: {
+                            readonly type: "string";
+                        };
+                        readonly value: {
+                            readonly type: "number";
+                        };
+                        readonly max: {
+                            readonly type: "number";
+                        };
+                        readonly columns: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly rows: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "array";
+                            };
+                        };
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly multiple: {
+                            readonly type: "boolean";
+                        };
+                        readonly options: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly label: {
+                                        readonly type: "string";
+                                    };
+                                    readonly description: {
+                                        readonly type: "string";
+                                    };
+                                    readonly status: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["normal", "standby", "caution", "serious", "critical", "off"];
+                                    };
+                                    readonly disabled: {
+                                        readonly type: "boolean";
+                                    };
+                                };
+                            };
+                        };
+                        readonly confirmLabel: {
+                            readonly type: "string";
+                        };
+                        readonly cancelLabel: {
+                            readonly type: "string";
+                        };
+                        readonly language: {
+                            readonly type: "string";
+                        };
+                        readonly command: {
+                            readonly type: "string";
+                        };
+                        readonly executable: {
+                            readonly type: "boolean";
+                        };
+                        readonly pairs: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly type: "string";
+                                    };
+                                    readonly value: {};
+                                    readonly mono: {
+                                        readonly type: "boolean";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * JSON system prompt snippet — instructs the LLM to respond with JSON.
+ * Include in your system prompt for the simplest integration path.
+ */
+export declare const CHAT_RESPONSE_JSON_PROMPT: "When reporting telemetry, status, or alerts, respond with a JSON object:\n\n{\n  \"content\": \"Plain text explanation (supports **markdown**).\",\n  \"severity\": \"normal\" | \"standby\" | \"caution\" | \"serious\" | \"critical\" | \"off\",\n  \"blocks\": [\n    { \"type\": \"alert\", \"status\": \"caution\", \"title\": \"Alert Title\", \"detail\": \"Description\" },\n    { \"type\": \"telemetry\", \"title\": \"Subsystem\", \"items\": [{ \"label\": \"Temp\", \"value\": 72, \"unit\": \"\u00B0C\", \"status\": \"normal\" }] },\n    { \"type\": \"progress\", \"label\": \"Operation\", \"value\": 75, \"max\": 100, \"status\": \"normal\" },\n    { \"type\": \"table\", \"title\": \"Data\", \"columns\": [\"Col1\", \"Col2\"], \"rows\": [[\"val1\", \"val2\"]] },\n    { \"type\": \"choice\", \"id\": \"unique-id\", \"title\": \"Pick one\", \"options\": [{ \"id\": \"opt1\", \"label\": \"Option 1\" }] },\n    { \"type\": \"confirm\", \"id\": \"unique-id\", \"status\": \"caution\", \"title\": \"Confirm action\" },\n    { \"type\": \"command\", \"id\": \"cmd-id\", \"command\": \"CMD SAT-001 EXECUTE\", \"executable\": true },\n    { \"type\": \"kv\", \"title\": \"Context\", \"pairs\": [{ \"key\": \"Spacecraft\", \"value\": \"SAT-001\" }] }\n  ]\n}\n\nStatus levels (Astro UX): normal (nominal), standby (idle), caution (approaching limit), serious (at limit), critical (exceeding limit), off (no data).\nAlways include \"content\". Only include \"blocks\" when structured data helps the operator.";
+/**
+ * YAML system prompt snippet — instructs the LLM to respond in compact YAML
+ * instead of JSON. ~30-40% fewer output tokens for the same data.
+ */
+export declare const CHAT_RESPONSE_YAML_PROMPT: "Respond in YAML format (not JSON). Use this structure:\n\ncontent: Your plain-text or markdown response here.\nseverity: normal\nblocks:\n  - type: alert\n    status: caution\n    title: Alert Title\n    detail: Optional detail\n  - type: telemetry\n    title: Subsystem\n    items:\n      - label: Parameter\n        value: 42.5\n        unit: \"\u00B0C\"\n        status: normal\n  - type: progress\n    label: Operation\n    value: 75\n    max: 100\n    status: normal\n  - type: choice\n    id: unique-id\n    title: Pick one\n    options:\n      - id: opt1\n        label: Option 1\n        status: normal\n  - type: command\n    id: cmd-id\n    language: CCSDS-TC\n    command: CMD SAT-001 EXECUTE\n    executable: true\n  - type: kv\n    title: Context\n    pairs:\n      - key: Spacecraft\n        value: SAT-001\n\nStatus levels (Astro UX): normal, standby, caution, serious, critical, off.\nAlways include \"content\". Only include \"blocks\" when structured data helps the operator.";
+/**
+ * Astro UX status rules snippet — append to any system prompt (JSON or YAML).
+ * Gives the LLM concrete thresholds for assigning status levels.
+ */
+export declare const CHAT_STATUS_RULES_PROMPT: "Assign status levels using these thresholds:\n- Battery: normal >50%, standby 30-50%, caution 20-30%, serious 10-20%, critical <10%\n- Temperature: normal <70\u00B0C, caution 70-80\u00B0C, serious 80-85\u00B0C, critical >85\u00B0C\n- Signal: normal >-80 dBm, caution -80 to -90, serious -90 to -95, critical <-95 dBm\n- Memory/Storage: normal <70%, caution 70-85%, serious 85-95%, critical >95%\n\nGeneral rules:\n- \"normal\"   \u2192 Operating within nominal parameters\n- \"standby\"  \u2192 Idle, waiting, or scheduled\n- \"caution\"  \u2192 Approaching a limit\n- \"serious\"  \u2192 At or exceeding a soft limit\n- \"critical\" \u2192 Exceeding hard limit, loss of signal, or failure\n- \"off\"      \u2192 Powered down, no data";
+export declare const ChatPanel: React.NamedExoticComponent<ChatPanelProps>;
+export default ChatPanel;