@slices.sh/ai-chat 0.1.0

package/dist/hooks/use-branches.js

@@ -0,0 +1,69 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+import {
+  conversationBranches,
+  branchPage,
+  editedParts,
+  awaitingApproval,
+  awaitingQuestion
+} from "../services/types.js";
+const EMPTY = [];
+const server = () => EMPTY;
+function useBranches(chat, enabled = true) {
+  const { messages, status, setMessages } = useChat({ chat });
+  const memory = useMemo(() => conversationBranches(chat), [chat]);
+  const locations = useSyncExternalStore(memory.watch, memory.snapshot, server);
+  const blocked = !enabled || status === "submitted" || status === "streaming" || awaitingApproval(messages) || awaitingQuestion(messages);
+  const available = useCallback(
+    () => enabled && chat.status !== "submitted" && chat.status !== "streaming" && !awaitingApproval(chat.messages) && !awaitingQuestion(chat.messages),
+    [chat, enabled]
+  );
+  const regenerate = useCallback(
+    (id) => {
+      const at = chat.messages.findIndex((message) => message.id === id);
+      if (!available() || chat.messages[at]?.role !== "assistant" || !chat.messages.slice(0, at).some((message) => message.role === "user"))
+        return;
+      if (memory.fork(chat.messages, id)) void chat.regenerate({ messageId: id });
+    },
+    [chat, memory, available]
+  );
+  const edit = useCallback(
+    (id, text) => {
+      if (!available()) return false;
+      const message = chat.messages.find((message2) => message2.id === id);
+      if (message?.role !== "user") return false;
+      const value = text.trim();
+      if (!value && !message.parts.some((part) => part.type === "file")) return false;
+      const previous = message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+      if (value === previous.trim()) return true;
+      if (!memory.fork(chat.messages, id)) return false;
+      void chat.sendMessage({
+        messageId: id,
+        role: "user",
+        parts: editedParts(message, value),
+        metadata: message.metadata
+      });
+      return true;
+    },
+    [chat, memory, available]
+  );
+  const move = useCallback(
+    (id, delta) => {
+      if (!available()) return;
+      const restored = memory.move(chat.messages, id, delta);
+      if (restored) {
+        chat.clearError();
+        setMessages(restored);
+      }
+    },
+    [chat, memory, available, setMessages]
+  );
+  return useMemo(
+    () => ({ blocked, page: (id) => branchPage(messages, id, locations), regenerate, edit, move }),
+    [blocked, messages, regenerate, edit, move, locations]
+  );
+}
+export {
+  useBranches
+};

package/dist/hooks/use-chat-instance.d.ts

@@ -0,0 +1,28 @@
+import { Chat } from "@ai-sdk/react";
+import { type ChatSettings } from "../services/types";
+import { type Enabled } from "@slices.sh/core";
+import type { AiChatMessage } from "../services/types";
+/** The AI SDK's own chat, typed with the metadata a route writes. */
+export type AiChat = Chat<AiChatMessage>;
+/**
+ * What answers a chat: one the app handed the screen, the installed backend's route, or
+ * nothing at all — which only an app with no backend installed ever sees.
+ */
+export type ChatSource = "given" | "installed" | "missing";
+export type ChatInstance = {
+    chat: AiChat;
+    source: ChatSource;
+    settings: ChatSettings | null;
+};
+/**
+ * The chat a screen runs: the one it was handed, or one over the installed backend.
+ *
+ * Handing one over is the AI SDK's own way of owning a conversation — its id, the messages
+ * it opens on, a transport with your headers — and a screen that is handed nothing still
+ * works, over the route `slices add` installed. Fixed for the mount: another chat is a
+ * remount with a `key`, never a new instance mid-turn.
+ */
+export declare function useChatInstance(name: string, given: AiChat | undefined, { config, enabled }?: {
+    config?: string;
+    enabled?: Enabled;
+}): ChatInstance;

package/dist/hooks/use-chat-instance.js

@@ -0,0 +1,44 @@
+"use client";
+import { Chat } from "@ai-sdk/react";
+import { chatSession, shouldContinueChat } from "../services/types.js";
+import { useEffect, useMemo, useState } from "react";
+import { enabledOf } from "@slices.sh/core";
+import { getAiChat } from "../services/optional.js";
+import { useReportMissingConfiguration } from "./use-report-missing-configuration.js";
+function useChatInstance(name, given, { config, enabled } = {}) {
+  const [own] = useState(() => installed(name, given !== void 0, config, enabled));
+  useEffect(() => () => void own.chat.stop(), [own]);
+  const instance = useMemo(
+    () => given && enabled !== false ? { chat: given, source: "given", settings: null } : own,
+    [given, own, enabled]
+  );
+  useReportMissingConfiguration(instance.chat);
+  return instance;
+}
+const MISSING = () => ({ chat: new Chat({}), source: "missing", settings: null });
+function installed(name, handed, config, enabled) {
+  if (enabled === false) return MISSING();
+  const client = getAiChat(config);
+  if (!client) {
+    if (!handed) enabledOf({ service: "ai-chat", config, enabled, where: "<Chat.Root>" });
+    return MISSING();
+  }
+  if (typeof enabled === "string" && enabled !== "optional") {
+    enabledOf({
+      service: "ai-chat",
+      config,
+      enabled,
+      where: "<Chat.Root>",
+      granted: (capabilities) => Object.keys(capabilities).filter((key) => capabilities[key])
+    });
+  }
+  const { transport, settings } = chatSession(client, name);
+  return {
+    chat: new Chat({ transport, sendAutomaticallyWhen: shouldContinueChat }),
+    source: "installed",
+    settings
+  };
+}
+export {
+  useChatInstance
+};

package/dist/hooks/use-chat-settings.d.ts

@@ -0,0 +1,11 @@
+import { type ChatSettings } from "../services/types";
+import type { AiChat } from "./use-chat-instance";
+export declare function useChatSettings(chat: AiChat, settings: ChatSettings | null, waiting: number): {
+    blocked: boolean;
+    model: (id: string) => void;
+    toggle: (id: string) => void;
+    removeLast: () => boolean;
+    choices: import("../services/choices").ChatChoices | null;
+    selection: import("../services/choices").ChatSelection;
+};
+export type ChatSettingsView = ReturnType<typeof useChatSettings>;

package/dist/hooks/use-chat-settings.js

@@ -0,0 +1,33 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useCallback, useEffect, useSyncExternalStore } from "react";
+import { awaitingApproval, awaitingQuestion } from "../services/types.js";
+const EMPTY = { choices: null, selection: {} };
+const empty = () => EMPTY;
+const watchNothing = () => () => {
+};
+function useChatSettings(chat, settings, waiting) {
+  const { status, messages } = useChat({ chat });
+  const state = useSyncExternalStore(settings?.watch ?? watchNothing, settings?.snapshot ?? empty, empty);
+  useEffect(() => {
+    void settings?.load();
+  }, [settings]);
+  const blocked = status === "submitted" || status === "streaming" || waiting > 0 || awaitingApproval(messages) || awaitingQuestion(messages);
+  const available = useCallback(() => !waiting && chat.status !== "submitted" && chat.status !== "streaming" && !awaitingApproval(chat.messages) && !awaitingQuestion(chat.messages), [chat, waiting]);
+  const model = useCallback((id) => {
+    if (available()) settings?.model(id);
+  }, [available, settings]);
+  const toggle = useCallback((id) => {
+    if (available()) settings?.toggle(id);
+  }, [available, settings]);
+  const removeLast = useCallback(() => {
+    const last = settings?.snapshot().selection.tools?.at(-1);
+    if (!last || !available()) return false;
+    settings.toggle(last);
+    return true;
+  }, [available, settings]);
+  return { ...state, blocked, model, toggle, removeLast };
+}
+export {
+  useChatSettings
+};

package/dist/hooks/use-chat-sink.d.ts

@@ -0,0 +1,19 @@
+import type { FileUIPart } from "ai";
+import type { Sink } from "@slices.sh/composer";
+import type { AiChat, ChatSource } from "./use-chat-instance";
+/**
+ * The chat as a destination for Composer: one concern, how a message gets into the
+ * conversation. Sending is the queue's `enqueue` while the chat queues, and a direct send
+ * (skipping an open question first) when it does not.
+ */
+export declare function useChatSink({ chat, source, config, queue, enqueue, stop, removeLast, }: {
+    chat: AiChat;
+    source: ChatSource;
+    config?: string;
+    queue: boolean;
+    enqueue(text: string, files?: readonly FileUIPart[]): void;
+    /** Stops the streaming reply; false when none was streaming. */
+    stop(): boolean;
+    /** Takes the last chosen optional tool off the next turn; false when there is none or the chat is busy. */
+    removeLast(): boolean;
+}): Sink | null;

package/dist/hooks/use-chat-sink.js

@@ -0,0 +1,56 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useMemo } from "react";
+import { currentRegistry } from "@slices.sh/core";
+import { readFileDataUrl } from "@slices.sh/core/platform/read-file";
+import { skipQuestions } from "../services/types.js";
+function attachmentsOf(config) {
+  const files = currentRegistry()?.get("ai-chat", config)?.provider.capabilities?.files;
+  if (files === false) return false;
+  if (files && typeof files === "object") return files;
+  return void 0;
+}
+async function partOf(file) {
+  const mediaType = file.type || "application/octet-stream";
+  const url = file.source ? await readFileDataUrl(file.source) : file.url;
+  if (!url) throw new Error(`${file.name} has no bytes to send`);
+  return { type: "file", filename: file.name, mediaType, url };
+}
+function useChatSink({
+  chat,
+  source,
+  config,
+  queue,
+  enqueue,
+  stop,
+  removeLast
+}) {
+  const { status } = useChat({ chat });
+  const running = status === "submitted" || status === "streaming";
+  const attachments = attachmentsOf(config);
+  const accept = useMemo(() => {
+    const open = {};
+    if (attachments !== void 0) open.attachments = attachments;
+    return open;
+  }, [attachments]);
+  return useMemo(() => {
+    if (source === "missing") return null;
+    return {
+      async submit(message) {
+        const text = (message.text ?? "").trim();
+        const files = await Promise.all((message.attachments ?? []).map(partOf));
+        if (queue) return enqueue(text, files);
+        await skipQuestions(chat);
+        await chat.sendMessage({ text, ...files.length ? { files } : {} });
+      },
+      busy: running,
+      whenBusy: queue ? "queue" : "hold",
+      accept,
+      stop,
+      removeLast
+    };
+  }, [source, queue, running, chat, enqueue, accept, stop, removeLast]);
+}
+export {
+  useChatSink
+};

package/dist/hooks/use-composer.d.ts

@@ -0,0 +1,33 @@
+import { type KeyboardEvent } from "react";
+export type ComposerAttachments = {
+    count: number;
+    blocked: boolean;
+};
+export type ComposerPlacement = "standalone" | "embedded";
+export type Composer = {
+    draft: string;
+    set(text: string): void;
+    /** Sends the draft, or the text given instead of it. */
+    submit(text?: string): void;
+    keyDown(event: KeyboardEvent): void;
+    /** Whether the composer refuses everything, whatever is in it. */
+    disabled: boolean;
+};
+/**
+ * The draft, and the two ways a person sends it.
+ *
+ * Enter sends and Shift+Enter breaks the line, which is what every chat does and what makes
+ * a textarea worth having over an input. `isComposing` is why this lives in a hook rather
+ * than in the part: an IME's Enter commits a candidate, and a chat that sent on it would
+ * send half a Japanese word.
+ *
+ * `submit` takes text because a suggestion button has none in the draft yet, and setting the
+ * draft then submitting in one handler would read the draft from before the set.
+ */
+export declare function useComposer({ onSend, scope, onStop, onRemoveLast, disabled, }: {
+    scope?: object;
+    onSend(text: string): void;
+    onStop?(): boolean;
+    onRemoveLast?(): boolean;
+    disabled?: boolean;
+}): Composer;

package/dist/hooks/use-composer.js

@@ -0,0 +1,45 @@
+"use client";
+import { useCallback, useMemo } from "react";
+import { useDraft } from "./use-draft.js";
+function useComposer({
+  onSend,
+  scope,
+  onStop,
+  onRemoveLast,
+  disabled = false
+}) {
+  const { draft, set: setDraft } = useDraft(scope);
+  const submit = useCallback(
+    (text) => {
+      const sending = text ?? draft;
+      if (disabled || sending.trim().length === 0) return;
+      onSend(sending);
+      setDraft("");
+    },
+    [disabled, draft, onSend, setDraft]
+  );
+  const keyDown = useCallback(
+    (event) => {
+      if (event.key === "Backspace" && !event.defaultPrevented && !event.repeat && !event.nativeEvent.isComposing && !event.altKey && !event.metaKey && !event.ctrlKey && !event.shiftKey && !disabled && draft.length === 0 && onRemoveLast?.()) {
+        event.preventDefault();
+        return;
+      }
+      if (event.key === "Escape" && !event.nativeEvent.isComposing && !draft.trim() && onStop?.()) {
+        event.preventDefault();
+        return;
+      }
+      if (event.key !== "Enter" || event.shiftKey && !event.metaKey && !event.ctrlKey || event.nativeEvent.isComposing)
+        return;
+      event.preventDefault();
+      submit();
+    },
+    [submit, draft, onStop, disabled, onRemoveLast]
+  );
+  return useMemo(
+    () => ({ draft, set: setDraft, submit, keyDown, disabled }),
+    [draft, submit, keyDown, disabled, setDraft]
+  );
+}
+export {
+  useComposer
+};

package/dist/hooks/use-context-usage.d.ts

@@ -0,0 +1,8 @@
+import type { AiChat } from "./use-chat-instance";
+export type ContextUsage = {
+    tokens: number;
+    capacity: number;
+    percent: number;
+};
+/** A completed request measurement, not a prediction for the draft or the next turn. */
+export declare function useContextUsage(chat: AiChat): ContextUsage | null;

package/dist/hooks/use-context-usage.js

@@ -0,0 +1,14 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+function useContextUsage(chat) {
+  const { messages, status } = useChat({ chat });
+  if (status === "submitted" || status === "streaming") return null;
+  const latest = messages.findLast((message) => message.role === "assistant");
+  const tokens = latest?.metadata?.contextTokens;
+  const capacity = latest?.metadata?.contextWindow;
+  if (typeof tokens !== "number" || !Number.isSafeInteger(tokens) || tokens < 0 || typeof capacity !== "number" || !Number.isSafeInteger(capacity) || capacity <= 0) return null;
+  return { tokens, capacity, percent: Math.min(100, Math.round(tokens / capacity * 100)) };
+}
+export {
+  useContextUsage
+};

package/dist/hooks/use-copied.d.ts

@@ -0,0 +1,14 @@
+export type Copied = {
+    /** True for a moment after a successful copy, and never after a refused one. */
+    copied: boolean;
+    copy(text: string): void;
+};
+/**
+ * Put a message on the clipboard, and say so for two seconds.
+ *
+ * The flag is the whole reason this is a hook: a copy button with no acknowledgement is a
+ * button people press twice. It is set only once the write resolves, because a browser that
+ * refuses the clipboard — an insecure origin, a denied permission — would otherwise say
+ * "Copied" about nothing.
+ */
+export declare function useCopied(): Copied;

package/dist/hooks/use-copied.js

@@ -0,0 +1,22 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+const SHOWN = 2e3;
+function useCopied() {
+  const [copied, setCopied] = useState(false);
+  const timer = useRef(null);
+  useEffect(() => () => void (timer.current && clearTimeout(timer.current)), []);
+  const copy = useCallback((text) => {
+    void navigator.clipboard?.writeText(text).then(
+      () => {
+        setCopied(true);
+        if (timer.current) clearTimeout(timer.current);
+        timer.current = setTimeout(() => setCopied(false), SHOWN);
+      },
+      () => setCopied(false)
+    );
+  }, []);
+  return { copied, copy };
+}
+export {
+  useCopied
+};

package/dist/hooks/use-draft.d.ts

@@ -0,0 +1,6 @@
+/** A Chat object owns its in-memory draft; same IDs never cross account or instance boundaries. */
+export declare function useDraft(scope?: object): {
+    draft: string;
+    set: (next: string) => void;
+};
+export type Draft = ReturnType<typeof useDraft>;

package/dist/hooks/use-draft.js

@@ -0,0 +1,38 @@
+"use client";
+import { useState, useSyncExternalStore } from "react";
+const drafts = /* @__PURE__ */ new WeakMap();
+function createDraft() {
+  let text = "";
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    read: () => text,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    set: (next) => {
+      if (next === text) return;
+      text = next;
+      listeners.forEach((listener) => listener());
+    }
+  };
+}
+function draftFor(scope) {
+  let store = drafts.get(scope);
+  if (!store) {
+    store = createDraft();
+    drafts.set(scope, store);
+  }
+  return store;
+}
+function useDraft(scope) {
+  const [local] = useState(createDraft);
+  const store = scope ? draftFor(scope) : local;
+  const draft = useSyncExternalStore(store.subscribe, store.read, store.read);
+  return { draft, set: store.set };
+}
+export {
+  useDraft
+};

package/dist/hooks/use-feedback.d.ts

@@ -0,0 +1,8 @@
+import type { ChatFeedback, ChatFeedbackOptions } from "../services/types";
+export declare function useFeedback(target: Pick<ChatFeedback, "chatId" | "messageId">, onFeedback: ChatFeedbackOptions["onFeedback"]): {
+    rating: "up" | "down" | null;
+    pending: boolean;
+    failed: boolean;
+    submit: (choice: "up" | "down") => Promise<void>;
+};
+export type Feedback = ReturnType<typeof useFeedback>;

package/dist/hooks/use-feedback.js

@@ -0,0 +1,28 @@
+"use client";
+import { useRef, useState } from "react";
+function useFeedback(target, onFeedback) {
+  const [rating, setRating] = useState(null);
+  const [pending, setPending] = useState(false);
+  const [failed, setFailed] = useState(false);
+  const busy = useRef(false);
+  const submit = async (choice) => {
+    if (!onFeedback || busy.current) return;
+    busy.current = true;
+    setPending(true);
+    setFailed(false);
+    const next = rating === choice ? null : choice;
+    try {
+      await onFeedback({ ...target, rating: next });
+      setRating(next);
+    } catch {
+      setFailed(true);
+    } finally {
+      busy.current = false;
+      setPending(false);
+    }
+  };
+  return { rating, pending, failed, submit };
+}
+export {
+  useFeedback
+};

package/dist/hooks/use-follow.d.ts

@@ -0,0 +1,15 @@
+export type Follow = {
+    following: boolean;
+    jump(): void;
+    /** The reader moved the transcript themselves: a wheel, a touch, a key, its scrollbar. */
+    release(): void;
+};
+/**
+ * The primitive owns anchoring and resize handling; this hook only exposes its controls.
+ *
+ * It opens a transcript, and places each new question, with the question at the top and its
+ * answer running on below: short of the end, yet nowhere the reader chose to go, so a way back
+ * to the end would point at a place nobody left. The transcript counts as followed there until
+ * the reader moves it, and again once they jump back or `turn`, the newest question, changes.
+ */
+export declare function useFollow(turn?: string): Follow;

package/dist/hooks/use-follow.js

@@ -0,0 +1,30 @@
+"use client";
+import { useCallback, useMemo, useState, useSyncExternalStore } from "react";
+import { useMessageScroller, useMessageScrollerScrollable } from "@shadcn/react/message-scroller";
+const REDUCED = "(prefers-reduced-motion: reduce)";
+function useFollow(turn = "") {
+  const reduced = useSyncExternalStore(watchReducedMotion, prefersReducedMotion, () => false);
+  const { scrollToEnd } = useMessageScroller();
+  const { end } = useMessageScrollerScrollable();
+  const [left, setLeft] = useState(null);
+  const held = left !== turn;
+  const release = useCallback(() => setLeft(turn), [turn]);
+  const jump = useCallback(() => {
+    setLeft(null);
+    scrollToEnd({ behavior: reduced ? "auto" : "smooth" });
+  }, [scrollToEnd, reduced]);
+  return useMemo(() => ({ following: !end || held, jump, release }), [end, held, jump, release]);
+}
+function prefersReducedMotion() {
+  return typeof window !== "undefined" && window.matchMedia(REDUCED).matches;
+}
+function watchReducedMotion(changed) {
+  if (typeof window === "undefined") return () => {
+  };
+  const query = window.matchMedia(REDUCED);
+  query.addEventListener("change", changed);
+  return () => query.removeEventListener("change", changed);
+}
+export {
+  useFollow
+};

package/dist/hooks/use-media-load.d.ts

@@ -0,0 +1,5 @@
+export type MediaLoad = {
+    failed: boolean;
+    fail: () => void;
+};
+export declare function useMediaLoad(url: string | null): MediaLoad;

package/dist/hooks/use-media-load.js

@@ -0,0 +1,12 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+function useMediaLoad(url) {
+  const [state, setState] = useState({ url, failed: false });
+  if (state.url !== url) setState({ url, failed: false });
+  const fail = useCallback(() => setState({ url, failed: true }), [url]);
+  const failed = state.url === url && state.failed;
+  return useMemo(() => ({ failed, fail }), [failed, fail]);
+}
+export {
+  useMediaLoad
+};

package/dist/hooks/use-media.d.ts

@@ -0,0 +1,3 @@
+import type { FileUIPart } from "ai";
+import { type ChatMedia } from "../services/types";
+export declare function useMedia(file: FileUIPart): ChatMedia;

package/dist/hooks/use-media.js

@@ -0,0 +1,9 @@
+"use client";
+import { useMemo } from "react";
+import { mediaOf } from "../services/types.js";
+function useMedia(file) {
+  return useMemo(() => mediaOf(file), [file]);
+}
+export {
+  useMedia
+};

package/dist/hooks/use-question-check.d.ts

@@ -0,0 +1,11 @@
+import { type QuestionProblem, type Questionnaire } from "../services/types";
+import type { QuestionDraft } from "./use-question-draft";
+export type QuestionCheck = {
+    /** What is wrong with a question's answer right now; null when nothing is. */
+    problem(name: string): QuestionProblem | null;
+    /** The same, but only once the person tried to go on, so a form never opens covered in errors. */
+    shown(name: string): QuestionProblem | null;
+    /** Starts showing these questions' problems, and says whether any of them has one. */
+    reveal(names: readonly string[]): boolean;
+};
+export declare function useQuestionCheck(input: Questionnaire, draft: QuestionDraft): QuestionCheck;

package/dist/hooks/use-question-check.js

@@ -0,0 +1,29 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+import { questionProblem } from "../services/types.js";
+function useQuestionCheck(input, draft) {
+  const [revealed, setRevealed] = useState(/* @__PURE__ */ new Set());
+  const problem = useCallback(
+    (name) => {
+      const question = input.questions.find((q) => q.name === name);
+      if (!question) return null;
+      const other = draft.other(name);
+      return questionProblem(question, draft.answers[name], other.on && !other.text.trim());
+    },
+    [input, draft]
+  );
+  const reveal = useCallback(
+    (names) => {
+      setRevealed((current) => /* @__PURE__ */ new Set([...current, ...names]));
+      return names.some((name) => problem(name) !== null);
+    },
+    [problem]
+  );
+  return useMemo(
+    () => ({ problem, shown: (name) => revealed.has(name) ? problem(name) : null, reveal }),
+    [problem, revealed, reveal]
+  );
+}
+export {
+  useQuestionCheck
+};

package/dist/hooks/use-question-draft.d.ts

@@ -0,0 +1,34 @@
+import type { QuestionAnswers, Questionnaire } from "../services/types";
+export { isSkippedQuestion, questionInput } from "../services/types";
+export type DraftChange = 
+/** Replaces the choice of a single question and toggles one of a multiple question. */
+{
+    type: "choose";
+    value: string;
+}
+/** The Other control: it replaces the choice of a single question and toggles beside a multiple one. */
+ | {
+    type: "toggle-other";
+}
+/** A click into Other's field chooses it without ever toggling it off. */
+ | {
+    type: "select-other";
+}
+/** Typing in Other is choosing it. */
+ | {
+    type: "write-other";
+    text: string;
+} | {
+    type: "clear";
+};
+export type QuestionDraft = {
+    /** What would be sent: only the questions that have something in them. */
+    answers: QuestionAnswers;
+    picked(name: string, value: string): boolean;
+    other(name: string): {
+        on: boolean;
+        text: string;
+    };
+    change(name: string, change: DraftChange): void;
+};
+export declare function useQuestionDraft(input: Questionnaire): QuestionDraft;