@theoremjs/react 0.0.0-stage → 0.3.0

package/ui/labels.d.ts

@@ -0,0 +1,1153 @@
+/**
+ * The default UI's words, as an Astryx i18n catalog under `@theorem.*` keys:
+ * the same mechanism that words Astryx's own components (`@astryx.*`), so one
+ * override table replaces any line on screen, per locale. Messages are ICU
+ * (`{handle}`, `{n, plural, …}`); `params` names the values each one is given.
+ * Failures are worded by the profile lexicon, not here.
+ *
+ * @module
+ */
+import type { ComposerDrawerSummary } from '../client/composer-drawer.ts';
+import type { LiveState } from '../client/live/live-state.ts';
+import type { WorkStatus } from '../client/transcript-groups.ts';
+export declare const THEOREM_UI_CATALOG: {
+    readonly '@theorem.agent.handle': {
+        readonly defaultMessage: "@{handle}";
+        readonly description: "The agent's name above its messages, on the landing and in captions.";
+        readonly params: readonly ["handle"];
+    };
+    readonly '@theorem.chat.greeting': {
+        readonly defaultMessage: "What are we working on?";
+        readonly description: "Chat landing heading, before the first message.";
+    };
+    readonly '@theorem.chat.loading': {
+        readonly defaultMessage: "Loading…";
+        readonly description: "Spinner label while the profile loads.";
+    };
+    readonly '@theorem.chat.live_unsupported.title': {
+        readonly defaultMessage: "Live profiles aren't supported here";
+        readonly description: "Shown when TheoremChat is pointed at a live profile.";
+    };
+    readonly '@theorem.chat.live_unsupported.description': {
+        readonly defaultMessage: "Use LiveRunner from @theoremjs/react/live.";
+        readonly description: "Where to go instead, under the live-profile warning.";
+    };
+    readonly '@theorem.composer.placeholder': {
+        readonly defaultMessage: "Message @{handle}";
+        readonly description: "Empty composer placeholder.";
+        readonly params: readonly ["handle"];
+    };
+    readonly '@theorem.composer.listening': {
+        readonly defaultMessage: "Listening…";
+        readonly description: "Composer placeholder while a voice note records.";
+    };
+    readonly '@theorem.composer.attach': {
+        readonly defaultMessage: "Attach files";
+        readonly description: "Paperclip button.";
+    };
+    readonly '@theorem.composer.record': {
+        readonly defaultMessage: "Record voice";
+        readonly description: "Microphone button, idle.";
+    };
+    readonly '@theorem.composer.stop_recording': {
+        readonly defaultMessage: "Stop recording";
+        readonly description: "Microphone button, recording.";
+    };
+    readonly '@theorem.composer.send_options': {
+        readonly defaultMessage: "More send options";
+        readonly description: "Menu button beside send.";
+    };
+    readonly '@theorem.composer.model': {
+        readonly defaultMessage: "Model";
+        readonly description: "Model selector (screen readers).";
+    };
+    readonly '@theorem.composer.effort': {
+        readonly defaultMessage: "Effort";
+        readonly description: "Effort selector (screen readers).";
+    };
+    readonly '@theorem.composer.menu.queue': {
+        readonly defaultMessage: "Queue";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.queue.description': {
+        readonly defaultMessage: "Send it once this reply finishes.";
+        readonly description: "Send menu item detail: the message waits its turn.";
+    };
+    readonly '@theorem.composer.menu.steer': {
+        readonly defaultMessage: "Steer this reply";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.steer.description': {
+        readonly defaultMessage: "Add it to the reply in progress. The agent reads it at its next step.";
+        readonly description: "Send menu item detail: the message joins the running reply instead of waiting.";
+    };
+    readonly '@theorem.composer.menu.send_now': {
+        readonly defaultMessage: "Send now";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.send_now.description': {
+        readonly defaultMessage: "Stop this reply and send it instead.";
+        readonly description: "Send menu item detail: ends the running reply (or its wait for approval), then sends.";
+    };
+    readonly '@theorem.composer.menu.stash': {
+        readonly defaultMessage: "Stash";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.stash.description': {
+        readonly defaultMessage: "Set it aside to send later.";
+        readonly description: "Send menu item detail: the message waits in the composer until sent.";
+    };
+    readonly '@theorem.composer.hint.stash-selected-draft.message': {
+        readonly defaultMessage: "Replacing this?";
+        readonly description: "Hint when the whole draft is selected and could be stashed.";
+    };
+    readonly '@theorem.composer.hint.stash-selected-draft.action': {
+        readonly defaultMessage: "Stash it";
+        readonly description: "The hint's button.";
+    };
+    readonly '@theorem.composer.drawer.steer': {
+        readonly defaultMessage: "steering";
+        readonly description: "Drawer header when only steering messages wait.";
+    };
+    readonly '@theorem.composer.drawer.queue': {
+        readonly defaultMessage: "queued";
+        readonly description: "Drawer header when only queued messages wait.";
+    };
+    readonly '@theorem.composer.drawer.stash': {
+        readonly defaultMessage: "stashed";
+        readonly description: "Drawer header when only stashed messages wait.";
+    };
+    readonly '@theorem.composer.drawer.attached': {
+        readonly defaultMessage: "attached";
+        readonly description: "Drawer header when only files wait.";
+    };
+    readonly '@theorem.composer.drawer.steer.count': {
+        readonly defaultMessage: "{n} steering";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.queue.count': {
+        readonly defaultMessage: "{n} queued";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.stash.count': {
+        readonly defaultMessage: "{n} stashed";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.attached.count': {
+        readonly defaultMessage: "{n} attached";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.separator': {
+        readonly defaultMessage: " · ";
+        readonly description: "Between the parts of a mixed drawer header.";
+    };
+    readonly '@theorem.composer.pending.steer': {
+        readonly defaultMessage: "Steering";
+        readonly description: "Badge on a waiting steering message.";
+    };
+    readonly '@theorem.composer.pending.queue': {
+        readonly defaultMessage: "Queued";
+        readonly description: "Badge on a waiting queued message.";
+    };
+    readonly '@theorem.composer.pending.stash': {
+        readonly defaultMessage: "Stashed";
+        readonly description: "Badge on a waiting stashed message.";
+    };
+    readonly '@theorem.composer.pending.edit': {
+        readonly defaultMessage: "Edit";
+        readonly description: "Waiting message: back into the composer.";
+    };
+    readonly '@theorem.composer.pending.queue_action': {
+        readonly defaultMessage: "Queue";
+        readonly description: "Stashed message: queue it.";
+    };
+    readonly '@theorem.composer.pending.send_now': {
+        readonly defaultMessage: "Send now";
+        readonly description: "Waiting message: send it now.";
+    };
+    readonly '@theorem.composer.pending.move_up': {
+        readonly defaultMessage: "Move up";
+        readonly description: "Waiting message: earlier.";
+    };
+    readonly '@theorem.composer.pending.move_down': {
+        readonly defaultMessage: "Move down";
+        readonly description: "Waiting message: later.";
+    };
+    readonly '@theorem.composer.pending.remove': {
+        readonly defaultMessage: "Remove";
+        readonly description: "Waiting message: discard.";
+    };
+    readonly '@theorem.transcript.copy': {
+        readonly defaultMessage: "Copy";
+        readonly description: "Copy a message.";
+    };
+    readonly '@theorem.transcript.copied': {
+        readonly defaultMessage: "Copied";
+        readonly description: "Right after copying a message.";
+    };
+    readonly '@theorem.transcript.now': {
+        readonly defaultMessage: "now";
+        readonly description: "Message time during its first minute.";
+    };
+    readonly '@theorem.transcript.generated_image': {
+        readonly defaultMessage: "Generated image";
+        readonly description: "Alt text for a generated image.";
+    };
+    readonly '@theorem.transcript.generated_video': {
+        readonly defaultMessage: "Generated video";
+        readonly description: "Alt text for a generated video.";
+    };
+    readonly '@theorem.transcript.open_generated_image': {
+        readonly defaultMessage: "Open generated image";
+        readonly description: "Opens the image full size.";
+    };
+    readonly '@theorem.transcript.generating_image': {
+        readonly defaultMessage: "Generating image";
+        readonly description: "Placeholder while an image generates.";
+    };
+    readonly '@theorem.transcript.sources': {
+        readonly defaultMessage: "Sources";
+        readonly description: "The row of source chips (screen readers).";
+    };
+    readonly '@theorem.transcript.tool_input': {
+        readonly defaultMessage: "Input";
+        readonly description: "A tool call's arguments, in its detail.";
+    };
+    readonly '@theorem.transcript.tool_input_edited': {
+        readonly defaultMessage: "Input (edited)";
+        readonly description: "A tool call's arguments after the user edited them on approval.";
+    };
+    readonly '@theorem.transcript.tool_output': {
+        readonly defaultMessage: "Output";
+        readonly description: "A tool call's result, in its detail.";
+    };
+    readonly '@theorem.transcript.tool_error': {
+        readonly defaultMessage: "Error";
+        readonly description: "A failed tool call's failure, in its detail.";
+    };
+    readonly '@theorem.data.view': {
+        readonly defaultMessage: "View as";
+        readonly description: "Switch between tool data drawn by its shape and its JSON.";
+    };
+    readonly '@theorem.data.shaped': {
+        readonly defaultMessage: "Data";
+        readonly description: "Tool data drawn as fields, sections and tables.";
+    };
+    readonly '@theorem.data.json': {
+        readonly defaultMessage: "JSON";
+        readonly description: "Tool data as its raw JSON.";
+    };
+    readonly '@theorem.data.item': {
+        readonly defaultMessage: "Item {index}";
+        readonly description: "A list row with no name of its own.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.data.none': {
+        readonly defaultMessage: "Empty";
+        readonly description: "An empty list or object in tool data.";
+    };
+    readonly '@theorem.data.yes': {
+        readonly defaultMessage: "Yes";
+        readonly description: "A true value in tool data.";
+    };
+    readonly '@theorem.data.no': {
+        readonly defaultMessage: "No";
+        readonly description: "A false value in tool data.";
+    };
+    readonly '@theorem.data.more': {
+        readonly defaultMessage: "{count} more — switch to JSON to see them";
+        readonly description: "Rows past the shown ones, left to the JSON view.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.data.large': {
+        readonly defaultMessage: "Too large to lay out — showing the first {size} of its JSON";
+        readonly description: "A payload too big to draw by its shape, shown as the start of its JSON.";
+        readonly params: readonly ["size"];
+    };
+    readonly '@theorem.transcript.copy_text.tool': {
+        readonly defaultMessage: "Tool: {name}";
+        readonly description: "A tool call in copied message text.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.transcript.copy_text.media': {
+        readonly defaultMessage: "[{mimeType} media]";
+        readonly description: "Media without a link, in copied message text.";
+        readonly params: readonly ["mimeType"];
+    };
+    readonly '@theorem.transcript.working': {
+        readonly defaultMessage: "Working…";
+        readonly description: "Turn status while running, start unknown.";
+    };
+    readonly '@theorem.transcript.working_for': {
+        readonly defaultMessage: "Working for {duration}";
+        readonly description: "Turn status while running.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.transcript.worked': {
+        readonly defaultMessage: "Worked";
+        readonly description: "Turn status once done, duration unknown.";
+    };
+    readonly '@theorem.transcript.worked_for': {
+        readonly defaultMessage: "Worked for {duration}";
+        readonly description: "Turn status once done.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.duration.milliseconds': {
+        readonly defaultMessage: "{ms}ms";
+        readonly description: "Under a second.";
+        readonly params: readonly ["ms"];
+    };
+    readonly '@theorem.duration.belowTenth': {
+        readonly defaultMessage: "<0.1ms";
+        readonly description: "Above zero but under a tenth of a millisecond, such as a quick guardrail check.";
+    };
+    readonly '@theorem.duration.seconds': {
+        readonly defaultMessage: "{seconds}s";
+        readonly description: "Under a minute.";
+        readonly params: readonly ["seconds"];
+    };
+    readonly '@theorem.duration.minutes': {
+        readonly defaultMessage: "{minutes}m";
+        readonly description: "Whole minutes.";
+        readonly params: readonly ["minutes"];
+    };
+    readonly '@theorem.duration.minutes_seconds': {
+        readonly defaultMessage: "{minutes}m {seconds}s";
+        readonly description: "Minutes and seconds.";
+        readonly params: readonly ["minutes", "seconds"];
+    };
+    readonly '@theorem.gate.approval.badge': {
+        readonly defaultMessage: "Approval required";
+        readonly description: "Tool approval card badge.";
+    };
+    readonly '@theorem.gate.approval.title': {
+        readonly defaultMessage: "Tool:";
+        readonly description: "Before the tool name on the approval card.";
+    };
+    readonly '@theorem.gate.approval.input': {
+        readonly defaultMessage: "Input arguments";
+        readonly description: "Expands the arguments the tool would run with.";
+    };
+    readonly '@theorem.gate.approval.deny': {
+        readonly defaultMessage: "Deny";
+        readonly description: "Approval card button.";
+    };
+    readonly '@theorem.gate.approval.approve': {
+        readonly defaultMessage: "Approve";
+        readonly description: "Approval card button.";
+    };
+    readonly '@theorem.gate.approval.denied': {
+        readonly defaultMessage: "Denied";
+        readonly description: "After denying.";
+    };
+    readonly '@theorem.gate.approval.approved_session': {
+        readonly defaultMessage: "Approved for this session";
+        readonly description: "After approving a tool whose consent lasts the session.";
+    };
+    readonly '@theorem.gate.approval.approved_once': {
+        readonly defaultMessage: "Approved once";
+        readonly description: "After approving a single run.";
+    };
+    readonly '@theorem.gate.tag.confirmation': {
+        readonly defaultMessage: "confirmation";
+        readonly description: "Gate kind tag.";
+    };
+    readonly '@theorem.gate.tag.permission': {
+        readonly defaultMessage: "permission";
+        readonly description: "Gate kind tag.";
+    };
+    readonly '@theorem.gate.tag.auth': {
+        readonly defaultMessage: "auth";
+        readonly description: "Gate kind tag.";
+    };
+    readonly '@theorem.gate.tag.auto': {
+        readonly defaultMessage: "auto";
+        readonly description: "Tool permission tag.";
+    };
+    readonly '@theorem.gate.tag.session_consent': {
+        readonly defaultMessage: "session_consent";
+        readonly description: "Tool permission tag.";
+    };
+    readonly '@theorem.gate.tag.always_confirm': {
+        readonly defaultMessage: "always_confirm";
+        readonly description: "Tool permission tag.";
+    };
+    readonly '@theorem.gate.tag.bearer': {
+        readonly defaultMessage: "bearer";
+        readonly description: "Credential type tag.";
+    };
+    readonly '@theorem.gate.tag.api_key': {
+        readonly defaultMessage: "api_key";
+        readonly description: "Credential type tag.";
+    };
+    readonly '@theorem.gate.tag.oauth2': {
+        readonly defaultMessage: "oauth2";
+        readonly description: "Credential type tag.";
+    };
+    readonly '@theorem.gate.auth.badge': {
+        readonly defaultMessage: "Sign-in required";
+        readonly description: "Credential card badge.";
+    };
+    readonly '@theorem.gate.auth.title': {
+        readonly defaultMessage: "Authentication:";
+        readonly description: "Before the tool name on the credential card.";
+    };
+    readonly '@theorem.gate.auth.resource': {
+        readonly defaultMessage: "Resource: {resource}";
+        readonly description: "What the credential is for.";
+        readonly params: readonly ["resource"];
+    };
+    readonly '@theorem.gate.auth.no_oauth': {
+        readonly defaultMessage: "No OAuth authorization endpoint is configured.";
+        readonly description: "OAuth tool without an authorization URL.";
+    };
+    readonly '@theorem.gate.auth.authorize': {
+        readonly defaultMessage: "Authorize with provider";
+        readonly description: "Opens the OAuth sign-in.";
+    };
+    readonly '@theorem.gate.auth.provided': {
+        readonly defaultMessage: "Credential provided for {slot}";
+        readonly description: "After submitting a credential or finishing an OAuth sign-in.";
+        readonly params: readonly ["slot"];
+    };
+    readonly '@theorem.gate.auth.api_key': {
+        readonly defaultMessage: "API key";
+        readonly description: "Secret field label, API-key tools.";
+    };
+    readonly '@theorem.gate.auth.bearer': {
+        readonly defaultMessage: "Bearer token";
+        readonly description: "Secret field label, bearer tools.";
+    };
+    readonly '@theorem.gate.auth.secret_placeholder': {
+        readonly defaultMessage: "Secret for slot ''{slot}''";
+        readonly description: "Secret field placeholder.";
+        readonly params: readonly ["slot"];
+    };
+    readonly '@theorem.gate.auth.secret_note': {
+        readonly defaultMessage: " ";
+        readonly description: "Under the secret field: how the host handles the credential. Blank by default, since only the host knows; the playground says it is used for one call.";
+    };
+    readonly '@theorem.gate.auth.submit': {
+        readonly defaultMessage: "Submit & continue";
+        readonly description: "Sends the credential.";
+    };
+    readonly '@theorem.voice_note.name': {
+        readonly defaultMessage: "voice.{format}";
+        readonly description: "A voice note's name, by audio format (webm, wav, mp3, m4a, ogg).";
+        readonly params: readonly ["format"];
+    };
+    readonly '@theorem.voice_note.unnamed': {
+        readonly defaultMessage: "voice note";
+        readonly description: "A voice note's name when its format is unknown.";
+    };
+    readonly '@theorem.voice_note.play': {
+        readonly defaultMessage: "Play {name}";
+        readonly description: "Voice note, paused.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.voice_note.pause': {
+        readonly defaultMessage: "Pause {name}";
+        readonly description: "Voice note, playing.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.voice_note.remove': {
+        readonly defaultMessage: "Remove {name}";
+        readonly description: "Unstages a voice note.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.decision.state': {
+        readonly defaultMessage: "State";
+        readonly description: "The JSON a decision is asked about (field label).";
+    };
+    readonly '@theorem.decision.state_size': {
+        readonly defaultMessage: "{size} of {limit}";
+        readonly description: "The state's size against the profile's limit, under the field.";
+        readonly params: readonly ["size", "limit"];
+    };
+    readonly '@theorem.decision.view': {
+        readonly defaultMessage: "Edit as";
+        readonly description: "Switch between the state as fields and as JSON.";
+    };
+    readonly '@theorem.decision.fields': {
+        readonly defaultMessage: "Fields";
+        readonly description: "The state edited field by field.";
+    };
+    readonly '@theorem.decision.add_item': {
+        readonly defaultMessage: "Add to {field}";
+        readonly description: "Adds a row to a list in the state.";
+        readonly params: readonly ["field"];
+    };
+    readonly '@theorem.decision.remove_item': {
+        readonly defaultMessage: "Remove {item}";
+        readonly description: "Removes a row from a list in the state.";
+        readonly params: readonly ["item"];
+    };
+    readonly '@theorem.decision.add_value': {
+        readonly defaultMessage: "Add a value";
+        readonly description: "A list of words in the state, while it is empty.";
+    };
+    readonly '@theorem.decision.invalid_json': {
+        readonly defaultMessage: "Not valid JSON yet";
+        readonly description: "The state doesn't parse.";
+    };
+    readonly '@theorem.decision.null_state': {
+        readonly defaultMessage: "State can’t be null";
+        readonly description: "The state is the JSON null.";
+    };
+    readonly '@theorem.decision.too_large': {
+        readonly defaultMessage: "Over the {limit} limit";
+        readonly description: "The state is larger than the profile's limit.";
+        readonly params: readonly ["limit"];
+    };
+    readonly '@theorem.decision.decide': {
+        readonly defaultMessage: "Decide";
+        readonly description: "Asks the questions about the state.";
+    };
+    readonly '@theorem.decision.deciding': {
+        readonly defaultMessage: "Deciding…";
+        readonly description: "The decide button while it runs.";
+    };
+    readonly '@theorem.decision.stop': {
+        readonly defaultMessage: "Stop";
+        readonly description: "Cancels the running decision.";
+    };
+    readonly '@theorem.decision.confidence': {
+        readonly defaultMessage: "{percent} sure";
+        readonly description: "How sure the model is of a choice or score; percent is formatted, e.g. '92%'.";
+        readonly params: readonly ["percent"];
+    };
+    readonly '@theorem.decision.option': {
+        readonly defaultMessage: "{label}, {percent}";
+        readonly description: "One option and its probability (screen readers); percent is formatted.";
+        readonly params: readonly ["label", "percent"];
+    };
+    readonly '@theorem.decision.score_of': {
+        readonly defaultMessage: "{score} of {max}";
+        readonly description: "A score on its scale from 0, e.g. 1.4 of 3.";
+        readonly params: readonly ["score", "max"];
+    };
+    readonly '@theorem.decision.type.choice': {
+        readonly defaultMessage: "Choice";
+        readonly description: "A question that picks one label.";
+    };
+    readonly '@theorem.decision.type.score': {
+        readonly defaultMessage: "Score";
+        readonly description: "A question that places the state on a scale.";
+    };
+    readonly '@theorem.decision.type.noul': {
+        readonly defaultMessage: "Noul";
+        readonly description: "A question answered with one number.";
+    };
+    readonly '@theorem.decision.tokens': {
+        readonly defaultMessage: "{count, plural, one {# token} other {# tokens}}";
+        readonly description: "Input tokens the decision used, in the line under the answers.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.host.tool': {
+        readonly defaultMessage: "Tool";
+        readonly description: "Picks which of the host’s tools to call (field label).";
+    };
+    readonly '@theorem.host.request': {
+        readonly defaultMessage: "Request";
+        readonly description: "The input a tool call sends (card heading).";
+    };
+    readonly '@theorem.host.response': {
+        readonly defaultMessage: "Response";
+        readonly description: "What a tool call returned (section heading).";
+    };
+    readonly '@theorem.host.run': {
+        readonly defaultMessage: "Run";
+        readonly description: "Calls the tool with the request.";
+    };
+    readonly '@theorem.host.image': {
+        readonly defaultMessage: "Image the tool returned";
+        readonly description: "Alt text for an image a tool returned beside its output.";
+    };
+    readonly '@theorem.host.running': {
+        readonly defaultMessage: "Running…";
+        readonly description: "The run button while the call runs.";
+    };
+    readonly '@theorem.host.stop': {
+        readonly defaultMessage: "Stop";
+        readonly description: "Cancels the running call.";
+    };
+    readonly '@theorem.host.missing': {
+        readonly defaultMessage: "Needs {fields}";
+        readonly description: "Required fields the request is still missing, under the form.";
+        readonly params: readonly ["fields"];
+    };
+    readonly '@theorem.host.shortcut': {
+        readonly defaultMessage: "⌘↵ to run";
+        readonly description: "The keyboard shortcut that runs the call, under the form.";
+    };
+    readonly '@theorem.host.no_tools': {
+        readonly defaultMessage: "This host has no tools yet";
+        readonly description: "A host profile that allows no tools.";
+    };
+    readonly '@theorem.host.earlier': {
+        readonly defaultMessage: "Earlier calls";
+        readonly description: "Heading over this page’s previous tool calls.";
+    };
+    readonly '@theorem.host.kind.function': {
+        readonly defaultMessage: "Function";
+        readonly description: "A tool that runs a function on the host.";
+    };
+    readonly '@theorem.host.kind.http': {
+        readonly defaultMessage: "HTTP";
+        readonly description: "A tool that calls an HTTP endpoint.";
+    };
+    readonly '@theorem.host.kind.mcp': {
+        readonly defaultMessage: "MCP";
+        readonly description: "A tool served by an MCP server.";
+    };
+    readonly '@theorem.host.access.read-only': {
+        readonly defaultMessage: "Read-only";
+        readonly description: "A tool that only reads.";
+    };
+    readonly '@theorem.host.access.read-write': {
+        readonly defaultMessage: "Read-write";
+        readonly description: "A tool that can change things.";
+    };
+    readonly '@theorem.host.access.destructive': {
+        readonly defaultMessage: "Destructive";
+        readonly description: "A tool that can delete or overwrite.";
+    };
+    readonly '@theorem.host.status.running': {
+        readonly defaultMessage: "Running";
+        readonly description: "A tool call in progress.";
+    };
+    readonly '@theorem.host.status.gate': {
+        readonly defaultMessage: "Waiting";
+        readonly description: "A tool call paused on approval or sign-in.";
+    };
+    readonly '@theorem.host.status.complete': {
+        readonly defaultMessage: "Done";
+        readonly description: "A tool call that returned.";
+    };
+    readonly '@theorem.host.status.error': {
+        readonly defaultMessage: "Failed";
+        readonly description: "A tool call that failed.";
+    };
+    readonly '@theorem.host.status.cancel': {
+        readonly defaultMessage: "Stopped";
+        readonly description: "A tool call that was cancelled.";
+    };
+    readonly '@theorem.panel.trace.name': {
+        readonly defaultMessage: "Trace";
+        readonly description: "Trace side panel (screen readers).";
+    };
+    readonly '@theorem.panel.trace.show': {
+        readonly defaultMessage: "Show trace";
+        readonly description: "Trace panel toggle, closed.";
+    };
+    readonly '@theorem.panel.trace.hide': {
+        readonly defaultMessage: "Hide trace";
+        readonly description: "Trace panel toggle, open.";
+    };
+    readonly '@theorem.panel.trace.resize': {
+        readonly defaultMessage: "Resize trace";
+        readonly description: "Trace panel drag handle.";
+    };
+    readonly '@theorem.panel.trace.empty.title': {
+        readonly defaultMessage: "No trace yet";
+        readonly description: "Empty trace panel.";
+    };
+    readonly '@theorem.panel.trace.empty.description': {
+        readonly defaultMessage: "Spans for each run will show here.";
+        readonly description: "Empty trace panel.";
+    };
+    readonly '@theorem.panel.trace.summary': {
+        readonly defaultMessage: "{traces, plural, one {# trace} other {# traces}} · {spans, plural, one {# span} other {# spans}}";
+        readonly description: "Trace panel line under the search: how many traces and spans it holds.";
+        readonly params: readonly ["traces", "spans"];
+    };
+    readonly '@theorem.panel.trace.separator': {
+        readonly defaultMessage: " · ";
+        readonly description: "Between facts on one trace panel line.";
+    };
+    readonly '@theorem.panel.trace.search': {
+        readonly defaultMessage: "Search spans";
+        readonly description: "Trace panel search (screen readers).";
+    };
+    readonly '@theorem.panel.trace.search.placeholder': {
+        readonly defaultMessage: "Filter by type, status, model, text…";
+        readonly description: "Trace panel search, empty.";
+    };
+    readonly '@theorem.panel.trace.search.text': {
+        readonly defaultMessage: "Any text";
+        readonly description: "Search field matching any text a span holds.";
+    };
+    readonly '@theorem.panel.trace.search.text.description': {
+        readonly defaultMessage: "Names, values and stored text.";
+        readonly description: "What the any-text search field matches.";
+    };
+    readonly '@theorem.panel.trace.no_match': {
+        readonly defaultMessage: "No spans match";
+        readonly description: "Trace panel, when the search matches nothing.";
+    };
+    readonly '@theorem.panel.trace.back': {
+        readonly defaultMessage: "Back";
+        readonly description: "Leaves an open span for its turn.";
+    };
+    readonly '@theorem.panel.trace.show_text': {
+        readonly defaultMessage: "Show text";
+        readonly description: "Reveals stored text, JSON or messages.";
+    };
+    readonly '@theorem.panel.trace.hide_text': {
+        readonly defaultMessage: "Hide text";
+        readonly description: "Hides revealed stored text.";
+    };
+    readonly '@theorem.panel.trace.other': {
+        readonly defaultMessage: "Other";
+        readonly description: "Group for attributes the trace catalog does not name.";
+    };
+    readonly '@theorem.panel.trace.yes': {
+        readonly defaultMessage: "Yes";
+        readonly description: "A true trace value.";
+    };
+    readonly '@theorem.panel.trace.no': {
+        readonly defaultMessage: "No";
+        readonly description: "A false trace value.";
+    };
+    readonly '@theorem.panel.trace.tokens': {
+        readonly defaultMessage: "Tokens";
+        readonly description: "Card of token counts.";
+    };
+    readonly '@theorem.panel.trace.errors': {
+        readonly defaultMessage: "Errors";
+        readonly description: "Card counting failed spans.";
+    };
+    readonly '@theorem.panel.trace.at_least': {
+        readonly defaultMessage: "At least {value}";
+        readonly description: "A total some calls did not report.";
+        readonly params: readonly ["value"];
+    };
+    readonly '@theorem.panel.trace.about': {
+        readonly defaultMessage: "About {value}";
+        readonly description: "A total with estimated counts.";
+        readonly params: readonly ["value"];
+    };
+    readonly '@theorem.panel.trace.offset': {
+        readonly defaultMessage: "+{duration}";
+        readonly description: "When an event happened, after its span started.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.panel.trace.unit.milliseconds': {
+        readonly defaultMessage: "ms";
+        readonly description: "Unit of a search field in milliseconds.";
+    };
+    readonly '@theorem.panel.trace.unit.seconds': {
+        readonly defaultMessage: "s";
+        readonly description: "Unit of a search field in seconds.";
+    };
+    readonly '@theorem.panel.trace.unit.usd': {
+        readonly defaultMessage: "USD";
+        readonly description: "Unit of a search field in US dollars.";
+    };
+    readonly '@theorem.panel.trace.turn': {
+        readonly defaultMessage: "{label} {index} of {count}";
+        readonly description: "Which root of the trace is shown: \"Turn 2 of 3\".";
+        readonly params: readonly ["label", "index", "count"];
+    };
+    readonly '@theorem.panel.trace.turns': {
+        readonly defaultMessage: "Turns";
+        readonly description: "List of every turn of the conversation; a row opens its turn.";
+    };
+    readonly '@theorem.panel.trace.conversation': {
+        readonly defaultMessage: "{count, plural, one {# turn} other {# turns}}";
+        readonly description: "Heading of the whole-conversation view: how many turns it holds.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.conversation.back': {
+        readonly defaultMessage: "All turns";
+        readonly description: "Leaves a turn for the whole-conversation view.";
+    };
+    readonly '@theorem.panel.trace.previous': {
+        readonly defaultMessage: "Previous turn";
+        readonly description: "Opens the turn before this one.";
+    };
+    readonly '@theorem.panel.trace.next': {
+        readonly defaultMessage: "Next turn";
+        readonly description: "Opens the turn after this one.";
+    };
+    readonly '@theorem.panel.trace.calls': {
+        readonly defaultMessage: "Tool calls";
+        readonly description: "List of every call of a host's trace; a row opens its call.";
+    };
+    readonly '@theorem.panel.trace.calls.count': {
+        readonly defaultMessage: "{count, plural, one {# tool call} other {# tool calls}}";
+        readonly description: "Heading of a host's whole-trace view: how many tool calls it holds.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.calls.back': {
+        readonly defaultMessage: "All tool calls";
+        readonly description: "Leaves a call for the host's whole-trace view.";
+    };
+    readonly '@theorem.panel.trace.calls.previous': {
+        readonly defaultMessage: "Previous call";
+        readonly description: "Opens the tool call before this one.";
+    };
+    readonly '@theorem.panel.trace.calls.next': {
+        readonly defaultMessage: "Next call";
+        readonly description: "Opens the tool call after this one.";
+    };
+    readonly '@theorem.panel.trace.steps': {
+        readonly defaultMessage: "Steps";
+        readonly description: "Card counting the model and tool calls of a turn.";
+    };
+    readonly '@theorem.panel.trace.steps.detail': {
+        readonly defaultMessage: "{calls, plural, one {# model call} other {# model calls}} · {tools, plural, one {# tool} other {# tools}}";
+        readonly description: "Under the steps count: how many were model calls and tool calls.";
+        readonly params: readonly ["calls", "tools"];
+    };
+    readonly '@theorem.panel.trace.failed': {
+        readonly defaultMessage: "{count} failed";
+        readonly description: "Under the steps count, when some failed.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.firstText': {
+        readonly defaultMessage: "First text";
+        readonly description: "Card: how long the person waited before any of the answer appeared.";
+    };
+    readonly '@theorem.panel.trace.rate': {
+        readonly defaultMessage: "{rate} tokens/s";
+        readonly description: "Under the first-text time: how fast the model wrote once it started.";
+        readonly params: readonly ["rate"];
+    };
+    readonly '@theorem.panel.trace.held': {
+        readonly defaultMessage: "{duration} held back";
+        readonly description: "Under the first-text time: how long guardrails held written text back before showing it.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.panel.trace.guardrails': {
+        readonly defaultMessage: "Guardrails";
+        readonly description: "Card: the time guardrail checks took in a turn.";
+    };
+    readonly '@theorem.panel.trace.guardrails.passed': {
+        readonly defaultMessage: "Passed: {checks}";
+        readonly description: "Under the guardrail checks that acted: the checks that let the text through, each with what it checked and its time.";
+        readonly params: readonly ["checks"];
+    };
+    readonly '@theorem.panel.trace.guardrails.from': {
+        readonly defaultMessage: "from {tool}";
+        readonly description: "A guardrail check: the tool the checked text came from.";
+        readonly params: readonly ["tool"];
+    };
+    readonly '@theorem.panel.trace.guardrails.detail': {
+        readonly defaultMessage: "{checks, plural, one {# check} other {# checks}} · {flagged, plural, =0 {all passed} other {# acted}}";
+        readonly description: "Under the guardrail time: how many checks ran, and how many redacted, flagged or blocked.";
+        readonly params: readonly ["checks", "flagged"];
+    };
+    readonly '@theorem.panel.trace.tokens.detail': {
+        readonly defaultMessage: "{input} in · {output} out";
+        readonly description: "Under the token total: tokens read and written.";
+        readonly params: readonly ["input", "output"];
+    };
+    readonly '@theorem.panel.trace.time': {
+        readonly defaultMessage: "Where the time went";
+        readonly description: "Bar splitting a turn into model, tool and other time.";
+    };
+    readonly '@theorem.panel.trace.time.model': {
+        readonly defaultMessage: "Model";
+        readonly description: "Time spent waiting on the model.";
+    };
+    readonly '@theorem.panel.trace.time.tools': {
+        readonly defaultMessage: "Tools";
+        readonly description: "Time spent running tools.";
+    };
+    readonly '@theorem.panel.trace.time.guardrails': {
+        readonly defaultMessage: "Guardrails";
+        readonly description: "Time guardrail checks took: on the input, the stream and the answer.";
+    };
+    readonly '@theorem.panel.trace.time.hooks': {
+        readonly defaultMessage: "Hooks";
+        readonly description: "Time the host's turn hooks took.";
+    };
+    readonly '@theorem.panel.trace.time.other': {
+        readonly defaultMessage: "Other";
+        readonly description: "Time spent on none of these: waiting between steps, the host, the network.";
+    };
+    readonly '@theorem.panel.trace.charts.calls': {
+        readonly defaultMessage: "Tokens per model call";
+        readonly description: "Chart of each model call: its tokens stacked as a bar.";
+    };
+    readonly '@theorem.panel.trace.charts.cached': {
+        readonly defaultMessage: "Cached";
+        readonly description: "Legend: input tokens read from cache.";
+    };
+    readonly '@theorem.panel.trace.charts.input': {
+        readonly defaultMessage: "Input";
+        readonly description: "Legend: input tokens read fresh.";
+    };
+    readonly '@theorem.panel.trace.charts.output': {
+        readonly defaultMessage: "Output";
+        readonly description: "Legend: tokens the model wrote.";
+    };
+    readonly '@theorem.panel.trace.charts.slowest': {
+        readonly defaultMessage: "Slowest steps";
+        readonly description: "Chart ranking the steps that took longest.";
+    };
+    readonly '@theorem.panel.trace.charts.modelShare': {
+        readonly defaultMessage: "{share} on the model";
+        readonly description: "Beside a chart's total time: the model's share.";
+        readonly params: readonly ["share"];
+    };
+    readonly '@theorem.panel.trace.charts.cachedShare': {
+        readonly defaultMessage: "{share} of input cached";
+        readonly description: "Beside a chart's total tokens: the input read from cache.";
+        readonly params: readonly ["share"];
+    };
+    readonly '@theorem.panel.trace.charts.turnTime': {
+        readonly defaultMessage: "Time per turn";
+        readonly description: "Chart of each turn: its model, tool and other time stacked.";
+    };
+    readonly '@theorem.panel.trace.charts.callTime': {
+        readonly defaultMessage: "Time per call";
+        readonly description: "Chart of each tool call of a host's trace: its tool, check and hook time stacked.";
+    };
+    readonly '@theorem.panel.trace.charts.turnTokens': {
+        readonly defaultMessage: "Tokens per turn";
+        readonly description: "Chart of each turn: its tokens stacked as a bar.";
+    };
+    readonly '@theorem.panel.trace.charts.turn': {
+        readonly defaultMessage: "Turn {index}";
+        readonly description: "A turn, by its order in the conversation.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.panel.trace.charts.hostCall': {
+        readonly defaultMessage: "Call {index}";
+        readonly description: "A tool call, by its order in a host's trace.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.panel.trace.charts.call': {
+        readonly defaultMessage: "Model call {index}";
+        readonly description: "A model call, by its order in the turn.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.panel.trace.charts.tokens': {
+        readonly defaultMessage: "{cached} cached · {fresh} new in · {output} out";
+        readonly description: "A model call's tokens: read from cache, read fresh, and written.";
+        readonly params: readonly ["cached", "fresh", "output"];
+    };
+    readonly '@theorem.panel.trace.story': {
+        readonly defaultMessage: "What happened";
+        readonly description: "The turn told step by step.";
+    };
+    readonly '@theorem.panel.trace.story.asked': {
+        readonly defaultMessage: "User asked";
+        readonly description: "The first step: what the user sent.";
+    };
+    readonly '@theorem.panel.trace.story.requested': {
+        readonly defaultMessage: "Asked for {count, plural, one {# tool} other {# tools}}";
+        readonly description: "A model call that answered with tool calls.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.story.wrote': {
+        readonly defaultMessage: "Wrote a reply";
+        readonly description: "A model call that answered with text.";
+    };
+    readonly '@theorem.panel.trace.story.answered': {
+        readonly defaultMessage: "Answered";
+        readonly description: "The last step: the turn ended with this answer.";
+    };
+    readonly '@theorem.panel.trace.story.failed': {
+        readonly defaultMessage: "Ended with an error";
+        readonly description: "The last step, when the turn failed.";
+    };
+    readonly '@theorem.panel.trace.timeline': {
+        readonly defaultMessage: "Timeline";
+        readonly description: "Every span of the turn on one time axis.";
+    };
+    readonly '@theorem.panel.trace.timeline.zoom': {
+        readonly defaultMessage: "Drag across the strip to zoom";
+        readonly description: "Hint beside the activity strip that zooms the timeline.";
+    };
+    readonly '@theorem.panel.trace.timeline.reset': {
+        readonly defaultMessage: "Show the whole turn";
+        readonly description: "Zooms the timeline back out to the full turn.";
+    };
+    readonly '@theorem.panel.trace.input': {
+        readonly defaultMessage: "Input";
+        readonly description: "What a span was given.";
+    };
+    readonly '@theorem.panel.trace.output': {
+        readonly defaultMessage: "Output";
+        readonly description: "What a span gave back.";
+    };
+    readonly '@theorem.panel.trace.details': {
+        readonly defaultMessage: "All details";
+        readonly description: "A span's every attribute, event and link.";
+    };
+    readonly '@theorem.panel.trace.close': {
+        readonly defaultMessage: "Close";
+        readonly description: "Closes the open span.";
+    };
+    readonly '@theorem.panel.captions.name': {
+        readonly defaultMessage: "Captions";
+        readonly description: "Captions side panel (screen readers).";
+    };
+    readonly '@theorem.panel.captions.show': {
+        readonly defaultMessage: "Show captions";
+        readonly description: "Captions panel toggle, closed.";
+    };
+    readonly '@theorem.panel.captions.hide': {
+        readonly defaultMessage: "Hide captions";
+        readonly description: "Captions panel toggle, open.";
+    };
+    readonly '@theorem.panel.captions.resize': {
+        readonly defaultMessage: "Resize captions";
+        readonly description: "Captions panel drag handle.";
+    };
+    readonly '@theorem.panel.captions.empty.title': {
+        readonly defaultMessage: "No captions yet";
+        readonly description: "Empty captions panel.";
+    };
+    readonly '@theorem.panel.captions.empty.description': {
+        readonly defaultMessage: "What you and the agent say will show here.";
+        readonly description: "Empty captions panel.";
+    };
+    readonly '@theorem.live.greeting': {
+        readonly defaultMessage: "Ready when you are.";
+        readonly description: "Live landing heading, before a call.";
+    };
+    readonly '@theorem.live.start_voice_call': {
+        readonly defaultMessage: "Start voice call";
+        readonly description: "Live landing, voice profiles.";
+    };
+    readonly '@theorem.live.start_call': {
+        readonly defaultMessage: "Start call";
+        readonly description: "Starts or restarts a call.";
+    };
+    readonly '@theorem.live.start_video_call': {
+        readonly defaultMessage: "Start video call";
+        readonly description: "Live landing, video profiles.";
+    };
+    readonly '@theorem.live.microphone': {
+        readonly defaultMessage: "Microphone";
+        readonly description: "Mic toggle.";
+    };
+    readonly '@theorem.live.mute': {
+        readonly defaultMessage: "Mute";
+        readonly description: "Mic toggle tooltip, unmuted.";
+    };
+    readonly '@theorem.live.unmute': {
+        readonly defaultMessage: "Unmute";
+        readonly description: "Mic toggle tooltip, muted.";
+    };
+    readonly '@theorem.live.camera': {
+        readonly defaultMessage: "Camera";
+        readonly description: "Camera toggle.";
+    };
+    readonly '@theorem.live.camera_on': {
+        readonly defaultMessage: "Turn camera on";
+        readonly description: "Camera toggle tooltip, off.";
+    };
+    readonly '@theorem.live.camera_off': {
+        readonly defaultMessage: "Turn camera off";
+        readonly description: "Camera toggle tooltip, on.";
+    };
+    readonly '@theorem.live.flip_camera': {
+        readonly defaultMessage: "Flip camera";
+        readonly description: "Switches front and back camera.";
+    };
+    readonly '@theorem.live.end_call': {
+        readonly defaultMessage: "End call";
+        readonly description: "Hangs up.";
+    };
+    readonly '@theorem.live.controls': {
+        readonly defaultMessage: "Call controls";
+        readonly description: "The control toolbar (screen readers).";
+    };
+    readonly '@theorem.live.new_session': {
+        readonly defaultMessage: "New session";
+        readonly description: "Captions divider between calls.";
+    };
+    readonly '@theorem.live.camera_preview': {
+        readonly defaultMessage: "Camera preview";
+        readonly description: "Self-view (screen readers).";
+    };
+    readonly '@theorem.live.state.calling_tool': {
+        readonly defaultMessage: "calling {tool}";
+        readonly description: "Call status: a tool runs.";
+        readonly params: readonly ["tool"];
+    };
+    readonly '@theorem.live.state.connecting': {
+        readonly defaultMessage: "connecting";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.requesting_mic': {
+        readonly defaultMessage: "requesting mic";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.speaking': {
+        readonly defaultMessage: "speaking";
+        readonly description: "Call status: the agent speaks.";
+    };
+    readonly '@theorem.live.state.connected': {
+        readonly defaultMessage: "connected";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.muted': {
+        readonly defaultMessage: "muted";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.listening': {
+        readonly defaultMessage: "listening";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.error': {
+        readonly defaultMessage: "error";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.ended': {
+        readonly defaultMessage: "ended";
+        readonly description: "Call status.";
+    };
+};
+/** The default UI's catalog: each line's default message, description and values. */
+export type TheoremUiCatalog = typeof THEOREM_UI_CATALOG;
+/** Every line the default UI writes. */
+export type TheoremLabelKey = keyof TheoremUiCatalog;
+/** The values a label's message is formatted with; none for a plain line. */
+export type TheoremLabelValues<K extends TheoremLabelKey> = TheoremUiCatalog[K] extends {
+    params: readonly (infer P extends string)[];
+} ? Record<P, string | number> : undefined;
+/** Words a label; the default UI gets one from Astryx's `useTranslator`. */
+export type LabelText = <K extends TheoremLabelKey>(key: K, values?: TheoremLabelValues<K>) => string;
+/**
+ * One locale's replacements: any `@theorem.*` line, and any of Astryx's own
+ * (`@astryx.*`, see `@astryxdesign/core/locales/en.json`).
+ */
+export type TheoremLabelOverrides = {
+    readonly [K in TheoremLabelKey]?: string;
+} & {
+    readonly [key: `@astryx.${string}`]: string;
+};
+/** Replacements by locale (`en`, `en-GB`, `de`, …), as Astryx's `overrides`. */
+export type TheoremLabels = {
+    readonly [locale: string]: TheoremLabelOverrides | undefined;
+};
+/** A single kind is just its word ("queued"); a mix spells out each count ("2 queued · 1 attached"). */
+export declare function composerDrawerLabel(t: LabelText, summary: ComposerDrawerSummary): string;
+/** Wall-clock duration, matching Seance's builder-trace formatter: "<0.1ms", "0.4ms", "850ms", "3.2s", "12s", "1m 5s". */
+export declare function workDuration(t: LabelText, durationMs: number): string;
+/** "Working for 12s" while streaming (when the start is known), "Worked for 3.2s" after. */
+export declare function workStatusLabel(t: LabelText, status: WorkStatus | null): string;
+/** A live call's status line; `calling_tool` names the tool. */
+export declare function liveStateLabel(t: LabelText, state: LiveState, toolName: string | null): string;
+/** A voice note's name from its audio format; the unnamed line when the format is unknown. */
+export declare function voiceNoteName(t: LabelText, format: string | undefined): string;
+/**
+ * Checks a label table before it renders: every `@theorem.*` key must exist
+ * and its message must format with that key's values only; with `strict`
+ * (the `labels` prop), every other key must be an `@astryx.*` line whose
+ * message parses. A host's own Astryx overrides are checked for `@theorem.*`
+ * keys only, since the rest may be the host app's own strings. Throws, naming
+ * the locale and key, so a typo fails at mount instead of showing a raw key or
+ * crashing mid-render.
+ */
+export declare function assertLabelOverrides(labels: TheoremLabels, strict: boolean): void;