@xp266/dshtui 0.1.0

package/lib/index-DqnaSXqP.d.mts

@@ -0,0 +1,823 @@
+import { ComponentType, ReactNode, Ref } from "react";
+import { Token } from "marked";
+import { ContentBlock } from "@deepseek-ai/dsh-llm";
+import { SessionEvent } from "@deepseek-ai/dsh-session";
+//#region src/core/segments.d.ts
+interface MarkStyle {
+  color?: string;
+  background?: string;
+  bold?: boolean;
+  italic?: boolean;
+  strike?: boolean;
+  underline?: boolean;
+}
+interface Segment {
+  text: string;
+  style: MarkStyle;
+}
+//#endregion
+//#region src/ui/message/md/palette.d.ts
+interface MdPalette {
+  plain: MarkStyle;
+  bold: MarkStyle;
+  italic: MarkStyle;
+  strike: MarkStyle;
+  link: MarkStyle;
+  inlineCode: MarkStyle;
+  quoteBar: MarkStyle;
+  hr: MarkStyle;
+  listMarker: MarkStyle;
+  taskDone: MarkStyle;
+  taskTodo: MarkStyle;
+  heading(level: number): MarkStyle;
+  codePlain: MarkStyle;
+  codeFallback: MarkStyle;
+}
+//#endregion
+//#region src/core/paste.d.ts
+type PendingImage = {
+  kind: 'path';
+  path: string;
+} | {
+  kind: 'data';
+  data: Uint8Array;
+  mediaType: string;
+  name?: string;
+};
+//#endregion
+//#region src/model/selection.d.ts
+interface LineSelection {
+  anchorRow: number;
+  anchorCol: number;
+  focusRow: number;
+  focusCol: number;
+  inMessage: boolean;
+}
+//#endregion
+//#region src/model/message.d.ts
+interface BubbleMessage {
+  kind: 'bubble';
+  id: string;
+  role: 'user' | 'assistant' | 'error';
+  content: string;
+  streaming?: boolean;
+  origin?: 'command';
+}
+interface CollapsibleMessage {
+  kind: 'collapsible';
+  id: string;
+  label: string;
+  body: string;
+  running: boolean;
+  collapsed: boolean;
+  bodyCol?: number;
+  thinking?: boolean;
+  streaming?: boolean;
+  startedAt?: number;
+}
+type DiffLineKind$1 = 'ctx' | 'del' | 'add';
+interface DiffLine$1 {
+  kind: DiffLineKind$1;
+  text: string;
+}
+/**
+ * Generic tool card: every tool shares one bubble shape. The header carries
+ * the tool name plus a parameter summary; the body shows the full arguments
+ * and result (or a diff / read window when the tool protocol produced one).
+ * No per-tool customization exists at this layer.
+ */
+interface ToolCardMessage {
+  kind: 'tool-card';
+  id: string;
+  tool: string;
+  /** Header text: tool name plus optional parameter summary. */
+  label: string;
+  /** Full call-side arguments, rendered verbatim while running (and after, for full disclosure). */
+  argsBody: string;
+  /** Full settled result text from the tool protocol. */
+  resultBody?: string;
+  bodyCol?: number;
+  diff?: {
+    path: string;
+    hunks: readonly (readonly DiffLine$1[])[];
+    backgrounds?: boolean;
+  };
+  /** Structured read window replacing the text result body. */
+  read?: ToolReadView;
+  /** True when the settled result reported isError without a structured error; the result text renders as the error. */
+  failed?: boolean;
+  /** Sub-calls dispatched under this call (code mode); rendered as a child list. */
+  nested?: readonly ToolCardMessage[];
+  error?: string;
+  exitCode?: number;
+  signal?: string;
+  running: boolean;
+  streaming?: boolean;
+  startedAt?: number;
+}
+interface CompactionMessage {
+  kind: 'compaction';
+  id: string;
+  compactionId: string;
+  running: boolean;
+  summary: string;
+  error?: string;
+  streaming?: boolean;
+}
+interface HomeLogoMessage {
+  kind: 'home-logo';
+  id: string;
+  /** Artwork lines after culling; empty when the terminal cannot fit the logo. */
+  lines: readonly string[];
+  /** One gradient color per artwork line, aligned with `lines`. */
+  colors: readonly string[];
+  /** Version banner lines rendered under the artwork inside the same bubble. */
+  info: readonly string[];
+}
+type MessageKind = 'bubble' | 'collapsible' | 'tool-card' | 'compaction' | 'custom' | 'home-logo';
+type Message = BubbleMessage | CollapsibleMessage | ToolCardMessage | CompactionMessage | CustomMessage | HomeLogoMessage;
+//#endregion
+//#region src/terminal/mouse.d.ts
+type MouseEventType = 'down' | 'up' | 'drag' | 'move' | 'scroll';
+interface MouseEventData {
+  type: MouseEventType;
+  button: number;
+  x: number;
+  y: number;
+  modifiers: {
+    shift: boolean;
+    alt: boolean;
+    ctrl: boolean;
+  };
+  scrollDirection?: 'up' | 'down';
+}
+//#endregion
+//#region src/ui/hooks/use-scroll.d.ts
+interface ScrollSnapshot {
+  top: number;
+  maxScroll: number;
+}
+//#endregion
+//#region src/contract/index.d.ts
+interface WindowHandle {
+  clickAt(y: number, x: number): void;
+  wheelAt(y: number, dir: -1 | 1): boolean;
+}
+interface WindowProps {
+  open: boolean;
+  onClose(): void;
+  handleRef?: Ref<WindowHandle>;
+}
+interface WindowCommandSpec {
+  name: string;
+  description: string;
+}
+interface WindowContribution {
+  id: string;
+  title: string;
+  component: ComponentType<WindowProps>;
+  order?: number;
+  command?: WindowCommandSpec;
+  required?: readonly string[];
+}
+interface TuiWindowsFace {
+  register(contribution: WindowContribution): () => void;
+}
+interface StatusLineContribution {
+  id: string;
+  order?: number;
+  render(props: {
+    columns: number;
+  }): string;
+}
+interface OverlayContribution {
+  id: string;
+  render(props: {
+    onClose(): void;
+  }): ReactNode;
+}
+interface TuiServicesFace {
+  register(name: string, service: unknown): () => void;
+}
+interface PaintArgs<I> {
+  item: I;
+  focused: boolean;
+  subCol: number;
+  cursor?: number;
+  width: number;
+  y: number;
+  x: number;
+  pressed: 'left' | 'right' | null;
+  clip: number;
+}
+interface ClickHit {
+  localX: number;
+  localY: number;
+  width: number;
+}
+interface ClickActions {
+  focus(subCol: number): void;
+  flash(side: 'left' | 'right'): void;
+}
+interface WidgetKeyApi {
+  cursor: number;
+  subCol: number;
+  setCursor(next: number): void;
+  navigate(direction: 'up' | 'down' | 'left' | 'right'): void;
+}
+interface WidgetDef<I extends {
+  type: string;
+}> {
+  height(item: I, width: number): number;
+  paintWidth(item: I): number;
+  render(paint: PaintArgs<I>): ReactNode;
+  searchTexts?(item: I, searchRight: boolean): string[];
+  stops?(item: I): number;
+  fullRowFocus?: boolean;
+  selectable?: boolean;
+  editable?: boolean;
+  caret?(item: I, cursor: number, width: number): {
+    dy: number;
+    dx: number;
+  };
+  onLeftRight?(item: I, direction: -1 | 1, api: WidgetKeyApi): boolean;
+  onEnter?(item: I, api: WidgetKeyApi): boolean;
+  onSpace?(item: I): void;
+  onClick?(item: I, hit: ClickHit, actions: ClickActions): boolean;
+  activate?(item: I): void;
+}
+interface TuiWidgetsFace {
+  register<I extends {
+    type: string;
+  }>(type: I['type'], def: WidgetDef<I>): () => void;
+}
+/**
+ * Open registry for plugin dialog item kinds. Declaration-merge a property
+ * named after your item kind (any key) whose value is the item object type
+ * carrying a `type` discriminant; the merged types join the `DialogItem`
+ * union so your widget def stays fully typed.
+ */
+interface DialogItemKinds {}
+interface ThemePaletteContribution {
+  id: string;
+  order?: number;
+  /** Which theme mode(s) this palette patch applies to; defaults to 'both'. */
+  mode?: 'dark' | 'light' | 'both';
+  /** Color name (a `Theme` palette key) to replacement hex/text value. */
+  colors: Readonly<Record<string, string>>;
+}
+interface TuiPaletteFace {
+  register(contribution: ThemePaletteContribution): () => void;
+  /** Read a palette color by key, including plugin-contributed keys. */
+  color(key: string): string | undefined;
+}
+interface ClipboardBackendContribution {
+  id: string;
+  order?: number;
+  readText?(): string | undefined | Promise<string | undefined>;
+  readImage?(): {
+    data: Uint8Array;
+    mediaType: string;
+  } | undefined | Promise<{
+    data: Uint8Array;
+    mediaType: string;
+  } | undefined>;
+  writeText?(text: string): boolean;
+}
+interface TuiClipboardFace {
+  register(contribution: ClipboardBackendContribution): () => void;
+}
+interface TuiKey {
+  upArrow: boolean;
+  downArrow: boolean;
+  leftArrow: boolean;
+  rightArrow: boolean;
+  pageDown: boolean;
+  pageUp: boolean;
+  home?: boolean;
+  end?: boolean;
+  return: boolean;
+  escape: boolean;
+  ctrl: boolean;
+  shift: boolean;
+  tab: boolean;
+  backspace: boolean;
+  delete: boolean;
+  meta: boolean;
+}
+interface KeyBindingContribution {
+  id: string;
+  order?: number;
+  /**
+   * Invoked for every terminal key event before builtin shell handling.
+   * Return true to consume the key; later bindings and builtin handling
+   * are skipped for that event.
+   */
+  handle(input: string, key: TuiKey): boolean;
+}
+interface TuiKeymapFace {
+  register(contribution: KeyBindingContribution): () => void;
+}
+interface PointerUiContext {
+  dialogOpen: boolean;
+  panelActive: boolean;
+  hintRegion: {
+    top: number;
+    bottom: number;
+  } | null;
+  rows: number;
+  columns: number;
+  messageHeight: number;
+  inputHeight: number;
+  scrollTop: number;
+  getScroll(): ScrollSnapshot;
+}
+interface PointerSession {
+  getSelection(): LineSelection | null;
+  setSelection(next: LineSelection | null): void;
+  scroll(next: number): void;
+  /** Start (-1/1) or stop (0) drag-follow auto scrolling of the message area. */
+  autoScroll(direction: -1 | 1 | 0): void;
+}
+interface PointerEventFrame {
+  event: MouseEventData;
+  session: PointerSession;
+  ui: PointerUiContext;
+}
+interface PointerHandlerContribution {
+  id: string;
+  order?: number;
+  /** Return true to claim the gesture; drag and up are then routed here exclusively. */
+  onDown(frame: PointerEventFrame): boolean;
+  onDrag?(frame: PointerEventFrame): void;
+  onUp?(frame: PointerEventFrame): void;
+  onWheel?(frame: PointerEventFrame): boolean;
+}
+/** Builtin gesture handlers live at order 100..190; see registerPointerHandler. */
+declare const POINTER_PLUGIN_ORDER = 300;
+interface HintMatcherContribution {
+  id: string;
+  order?: number;
+  match(entries: readonly HintEntry[], context: {
+    value: string;
+    query: string;
+  }): HintEntry[] | null;
+}
+interface HintEntry {
+  command: string;
+  description: string;
+  hint?: string;
+}
+interface HintArgsContribution {
+  id: string;
+  order?: number;
+  args(name: string): string[] | null | Promise<string[] | null>;
+}
+interface TuiHintFace {
+  matchers: {
+    register(contribution: HintMatcherContribution): () => void;
+  };
+  args: {
+    register(contribution: HintArgsContribution): () => void;
+  };
+}
+interface TuiPointerFace {
+  register(contribution: PointerHandlerContribution): () => void;
+}
+interface SelectionExtractContext {
+  messageText(sel: LineSelection): string;
+  chromeText(sel: LineSelection): string;
+}
+interface SelectionDomainContribution {
+  id: string;
+  order?: number;
+  hit(sel: LineSelection): boolean;
+  extract(sel: LineSelection, context: SelectionExtractContext): string | null;
+}
+interface SelectionTransformerContribution {
+  id: string;
+  order?: number;
+  transform(text: string): string;
+}
+interface SelectionClipboardContribution {
+  id: string;
+  order?: number;
+  copy(text: string): boolean;
+}
+interface TuiSelectionFace {
+  domains: {
+    register(contribution: SelectionDomainContribution): () => void;
+  };
+  transformers: {
+    register(contribution: SelectionTransformerContribution): () => void;
+  };
+  clipboard: {
+    register(contribution: SelectionClipboardContribution): () => void;
+  };
+}
+interface InputStatusContext {
+  columns: number;
+  rows: number;
+  busy: boolean;
+  running: boolean;
+  modelName: string;
+  permissionMode: string;
+  effortName: string | undefined;
+  presetName: string | undefined;
+}
+interface InputStatusPart {
+  text: string;
+  color?: string;
+  bold?: boolean;
+}
+interface InputStatusContribution {
+  id: string;
+  order?: number;
+  /** Return one part, an array of parts, or null to contribute nothing this render. */
+  render(context: InputStatusContext): InputStatusPart | InputStatusPart[] | null;
+}
+interface HomeLogoContribution {
+  id: string;
+  order?: number;
+  /** Logo artwork rendered as the first chat-styled bubble on the home page, one string per terminal row. */
+  lines: readonly string[];
+}
+interface TuiHomeLogoFace {
+  register(contribution: HomeLogoContribution): () => void;
+}
+interface TuiChromeFace {
+  statusLine: {
+    register(contribution: StatusLineContribution): () => void;
+  };
+  overlays: {
+    register(contribution: OverlayContribution): () => void;
+  };
+  widgets: TuiWidgetsFace;
+  palette: TuiPaletteFace;
+  keys: TuiKeymapFace;
+  inputStatus: {
+    register(contribution: InputStatusContribution): () => void;
+  };
+  logo: TuiHomeLogoFace;
+}
+interface CommandDef {
+  id: string;
+  command: string;
+  description: string;
+  hint?: string;
+  args?: readonly string[];
+  run?: () => void;
+  order?: number;
+}
+interface TuiCommandsFace {
+  register(def: CommandDef): () => void;
+}
+type DiffLineKind = 'ctx' | 'del' | 'add';
+interface DiffLine {
+  kind: DiffLineKind;
+  text: string;
+}
+type DiffHunk = readonly DiffLine[];
+interface ToolViewDiff {
+  path: string;
+  hunks: readonly DiffHunk[];
+  /**
+   * Paint whole-line red/green backgrounds behind removed and added lines.
+   * Defaults to true when any line is a removal, false for pure additions.
+   * Set it explicitly to override that heuristic.
+   */
+  backgrounds?: boolean;
+}
+interface ToolResultView {
+  content: readonly ContentBlock[];
+  isError: boolean;
+  meta?: unknown;
+}
+interface ToolViewCallContext {
+  tool: string;
+  callId: string;
+  args: unknown;
+  argumentsRaw: string;
+  cwd: string;
+}
+interface ToolViewResultContext {
+  tool: string;
+  callId: string;
+  args: unknown;
+  result: ToolResultView;
+  cwd: string;
+}
+interface ToolCallPresentation {
+  label?: string;
+  body?: string;
+  bodyCol?: number;
+  diff?: ToolViewDiff;
+}
+interface ToolResultPresentation {
+  kind: 'replace' | 'append';
+  text: string;
+  /** Header replacement applied when kind is 'replace' ('' clears the suffix). */
+  label?: string;
+  /** Call-side body replacement ('' clears it), for settled views that supersede the args. */
+  argsBody?: string;
+  exitCode?: number;
+  signal?: string;
+  bodyCol?: number;
+  diff?: ToolViewDiff;
+  /** Structured read window; rendered as a numbered code card. */
+  read?: ToolReadView;
+}
+/** One numbered line of a structured read result. */
+interface ToolReadLine {
+  number: number;
+  text: string;
+}
+/** The `card: 'read'` projection: a numbered file window plus its totals. */
+interface ToolReadView {
+  path?: string;
+  lines: readonly ToolReadLine[];
+  /** 1-based first line of the window when it carries no lines. */
+  offset?: number;
+  /** Total lines in the file, for a "lines N of M" footer. */
+  totalLines?: number;
+  /** Syntax highlighting hint (e.g. `ts`). */
+  lang?: string;
+}
+interface ToolViewContribution {
+  tool: string;
+  order?: number;
+  /**
+   * When true, the builtin presenter never runs for this tool: a call or
+   * result handler returning undefined renders as a bare card instead of
+   * falling through to the builtin presentation.
+   */
+  takeover?: boolean;
+  call?(context: ToolViewCallContext): ToolCallPresentation | undefined;
+  result?(context: ToolViewResultContext): ToolResultPresentation | undefined;
+}
+interface TuiToolsFace {
+  register(contribution: ToolViewContribution): () => void;
+}
+interface CustomMessage {
+  kind: 'custom';
+  id: string;
+  view: string;
+  data: unknown;
+  running?: boolean;
+  streaming?: boolean;
+}
+type CustomMessageSeed = Omit<CustomMessage, 'kind' | 'id'>;
+interface ChatNodeDefinition {
+  id: string;
+  order?: number;
+  match(event: SessionEvent): boolean;
+  start(event: SessionEvent): CustomMessageSeed;
+  update?(event: SessionEvent, message: CustomMessage): CustomMessageSeed | null;
+}
+interface MessageViewContext {
+  message: CustomMessage;
+  width: number;
+}
+interface MessageViewRender {
+  label?: string;
+  lines: readonly string[];
+  wrap?: boolean;
+  muted?: boolean;
+}
+interface MessageViewContribution {
+  view: string;
+  order?: number;
+  render(context: MessageViewContext): MessageViewRender;
+}
+interface MessageRendererResult {
+  lines: string[];
+  rows?: Segment[][] | null;
+  bgs?: (string | undefined)[] | null;
+  customLabel?: string;
+  customMuted?: boolean;
+}
+interface MessageRendererContribution {
+  /** Message kind to take over: 'bubble' | 'collapsible' | 'tool-card' | 'compaction' | 'custom'. */
+  kind: string;
+  order?: number;
+  /** Return undefined to fall through to the builtin rendering. */
+  render(message: Message, width: number): MessageRendererResult | undefined;
+}
+interface TuiContentFace {
+  nodes: {
+    register(definition: ChatNodeDefinition): () => void;
+  };
+  views: {
+    register(contribution: MessageViewContribution): () => void;
+  };
+  renderers: {
+    register(contribution: MessageRendererContribution): () => void;
+  };
+}
+interface TuiStartupSink {
+  id: string;
+  /** Invoked for each boot progress line while the shell is starting. */
+  write(line: string): void;
+}
+interface TuiStartupFace {
+  registerSink(sink: TuiStartupSink): () => void;
+}
+interface SpecialFieldStyle {
+  color: string;
+  background: string;
+  bold?: boolean;
+}
+interface SpecialFieldContribution {
+  kind: string;
+  style(): SpecialFieldStyle;
+  /** Text injected into the sent message for a field of this kind; defaults to the label. */
+  expand?(data: unknown): string;
+}
+interface TuiFieldsFace {
+  register(contribution: SpecialFieldContribution): () => void;
+}
+/**
+ * Create a special field instance rendered as an inline chip with its own
+ * background. The returned sentinel char behaves like a single grapheme:
+ * cursor movement and deletion treat it atomically and line wrapping never
+ * splits it. `kind` resolves the style from registered field kinds.
+ */
+interface SpecialFieldCreateInput {
+  kind: string;
+  label: string;
+  /** Which reclaim scan owns the slot: 'composer' chips die with composer text, 'message' chips with the message list. */
+  owner?: 'composer' | 'message';
+}
+interface SpecialFieldFactory {
+  create(input: SpecialFieldCreateInput): string | null;
+  release(char: string): void;
+  /** Protect a chip from the automatic reclaim scans until the disposer runs. */
+  pin(char: string): (() => void) | undefined;
+  isFieldChar(char: string): boolean;
+  labelOf(char: string): string | undefined;
+}
+interface PasteContext {
+  /** Raw pasted text with normalized newlines. */
+  text: string;
+  /** Insert at this char index in the composer value. */
+  cursor: number;
+}
+interface PasteResult {
+  /** Text to insert (may contain field sentinel chars created via the field factory). */
+  insert: string;
+}
+interface PasteHandlerContribution {
+  id: string;
+  order?: number;
+  /** Return a result to claim the paste; return undefined to fall through. */
+  handle(context: PasteContext): PasteResult | undefined;
+}
+interface ComposerInsertSpec {
+  /** Plain text to insert at the cursor. */
+  text?: string;
+  /** A special field chip to insert at the cursor; `data` is passed to the kind's expand on send. */
+  field?: {
+    kind: string;
+    label: string;
+    data?: unknown;
+  };
+}
+interface TuiComposerFace {
+  paste: {
+    register(handler: PasteHandlerContribution): () => void;
+  };
+  /**
+   * Intercept a key before the builtin composer handling consumes it.
+   * Runs for every key routed to the composer (only while it is interactive);
+   * return true to consume the event.
+   */
+  keys: {
+    register(binding: {
+      id: string;
+      order?: number;
+      handle(input: string, key: TuiKey): boolean;
+    }): () => void;
+  };
+  /** Insert text or a special field into the live composer at the cursor. False when the composer is not mounted. */
+  insert(spec: ComposerInsertSpec): boolean;
+}
+interface MarkdownInlineContext {
+  palette: MdPalette;
+  base?: MarkStyle;
+}
+interface MarkdownBlockContext {
+  palette: MdPalette;
+  thinking: boolean;
+  width: number;
+  streamId: string;
+}
+/**
+ * A custom markdown block renderer. Keyed by the marked token `type` it
+ * claims (`code`, `heading`, `table`, ...). Registering over an existing
+ * type replaces that layer; disposing restores it (layered registry
+ * semantics).
+ */
+interface MarkdownBlockContribution {
+  /** marked token type this renderer claims. */
+  type: string;
+  order?: number;
+  render(token: Token, context: MarkdownBlockContext): Segment[][];
+}
+/** A custom inline (span-level) markdown token renderer, keyed by token `type`. */
+interface MarkdownInlineContribution {
+  type: string;
+  order?: number;
+  render(token: Token, context: MarkdownInlineContext): Segment;
+}
+interface PrismGrammarContribution {
+  /** Code fence language id (lowercase). */
+  id: string;
+  /** Prism grammar object (from a loaded prism component or hand-built). */
+  grammar: unknown;
+  /** Extra aliases accepted for the same grammar. */
+  aliases?: readonly string[];
+}
+interface TuiMarkdownFace {
+  blocks: {
+    register(contribution: MarkdownBlockContribution): () => void;
+  };
+  inline: {
+    register(contribution: MarkdownInlineContribution): () => void;
+  };
+  languages: {
+    register(contribution: PrismGrammarContribution): () => void;
+  };
+}
+interface InteractionPanelComponentProps {
+  request: unknown;
+  resolve(value: unknown): void;
+  reject(cause: unknown): void;
+  active: boolean;
+  columns: number;
+  rows: number;
+  innerWidth: number;
+  blockWidth: number;
+  background: string;
+  handleRef?: {
+    current: unknown;
+  };
+  onResize(height: number): void;
+}
+interface InteractionPanelContribution {
+  kind: string;
+  order?: number;
+  component: ComponentType<InteractionPanelComponentProps>;
+}
+interface TuiInteractionPanelsFace {
+  register(contribution: InteractionPanelContribution): () => void;
+}
+interface TuiInteractionsFace {
+  panels: TuiInteractionPanelsFace;
+  /** Queue a plugin interaction; resolves when the panel for `kind` settles it. */
+  push(kind: string, request: unknown, signal?: AbortSignal): Promise<unknown>;
+}
+interface TuiSessionSummary {
+  id: string;
+  name: string;
+  directory: string;
+  ungrouped: boolean;
+  updatedAt: number;
+  modifiedAt?: number;
+}
+interface TuiChatFace {
+  cwd(): string;
+  activeSessionId(): string;
+  onEvent(listener: (event: SessionEvent) => void): () => void;
+  send(text: string, images?: ReadonlyArray<readonly PendingImage[]>): void;
+  interrupt(): void;
+  newSession(): Promise<void>;
+  openSession(id: string): Promise<void>;
+  listSessions(): Promise<TuiSessionSummary[]>;
+}
+interface TuiExtensionPoint {
+  windows: TuiWindowsFace;
+  services: TuiServicesFace;
+  chrome: TuiChromeFace;
+  commands: TuiCommandsFace;
+  tools: TuiToolsFace;
+  content: TuiContentFace;
+  startup: TuiStartupFace;
+  fields: TuiFieldsFace & {
+    factory: SpecialFieldFactory;
+  };
+  composer: TuiComposerFace;
+  markdown: TuiMarkdownFace;
+  hint: TuiHintFace;
+  pointer: TuiPointerFace;
+  selection: TuiSelectionFace;
+  clipboard: TuiClipboardFace;
+  interactions?: TuiInteractionsFace;
+  chat?: TuiChatFace;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    tui: TuiExtensionPoint;
+  }
+}
+//#endregion
+export { ToolCallPresentation as $, MessageViewContribution as A, TuiToolsFace as At, PointerSession as B, MouseEventData as Bt, MarkdownBlockContext as C, TuiPaletteFace as Ct, MessageRendererContribution as D, TuiSessionSummary as Dt, MarkdownInlineContribution as E, TuiServicesFace as Et, PasteContext as F, WindowCommandSpec as Ft, SelectionExtractContext as G, Segment as Gt, PrismGrammarContribution as H, MessageKind as Ht, PasteHandlerContribution as I, WindowContribution as It, SpecialFieldCreateInput as J, SelectionTransformerContribution as K, PasteResult as L, WindowHandle as Lt, OverlayContribution as M, TuiWindowsFace as Mt, POINTER_PLUGIN_ORDER as N, WidgetDef as Nt, MessageRendererResult as O, TuiStartupFace as Ot, PaintArgs as P, WidgetKeyApi as Pt, ThemePaletteContribution as Q, PointerEventFrame as R, WindowProps as Rt, KeyBindingContribution as S, TuiMarkdownFace as St, MarkdownInlineContext as T, TuiSelectionFace as Tt, SelectionClipboardContribution as U, LineSelection as Ut, PointerUiContext as V, MouseEventType as Vt, SelectionDomainContribution as W, PendingImage as Wt, SpecialFieldStyle as X, SpecialFieldFactory as Y, StatusLineContribution as Z, InputStatusContext as _, TuiHomeLogoFace as _t, CommandDef as a, ToolViewContribution as at, InteractionPanelComponentProps as b, TuiKey as bt, CustomMessageSeed as c, TuiChatFace as ct, DiffLine as d, TuiCommandsFace as dt, ToolReadLine as et, DiffLineKind as f, TuiComposerFace as ft, HomeLogoContribution as g, TuiHintFace as gt, HintMatcherContribution as h, TuiFieldsFace as ht, ClipboardBackendContribution as i, ToolViewCallContext as it, MessageViewRender as j, TuiWidgetsFace as jt, MessageViewContext as k, TuiStartupSink as kt, DialogItemKinds as l, TuiChromeFace as lt, HintEntry as m, TuiExtensionPoint as mt, ClickActions as n, ToolResultPresentation as nt, ComposerInsertSpec as o, ToolViewDiff as ot, HintArgsContribution as p, TuiContentFace as pt, SpecialFieldContribution as q, ClickHit as r, ToolResultView as rt, CustomMessage as s, ToolViewResultContext as st, ChatNodeDefinition as t, ToolReadView as tt, DiffHunk as u, TuiClipboardFace as ut, InputStatusContribution as v, TuiInteractionPanelsFace as vt, MarkdownBlockContribution as w, TuiPointerFace as wt, InteractionPanelContribution as x, TuiKeymapFace as xt, InputStatusPart as y, TuiInteractionsFace as yt, PointerHandlerContribution as z, ScrollSnapshot as zt };