@accurix/centrinfo-widget 1.0.0 → 1.0.1

package/dist/types-rfkc-TtX.d.cts

@@ -0,0 +1,658 @@
+//#region src/i18n.d.ts
+/**
+ * Every user-visible chrome string in one place. The widget ships English
+ * defaults; a host localises by passing `labels` to `Centrinfo.init()` —
+ * any subset is merged over the defaults (see `mergeStrings`). The chat
+ * *answers* are already multilingual server-side (the RAG mirrors the
+ * visitor's language); this covers the surrounding UI that the backend
+ * never produces.
+ */
+interface WidgetStrings {
+  openChat: string;
+  closeChat: string;
+  muteSounds: string;
+  unmuteSounds: string;
+  /** Header presence line when the org is reachable. */
+  statusOnline: string;
+  /** Header presence line when bootstrap was loaded with `offline`. */
+  statusOffline: string;
+  composerPlaceholder: string;
+  send: string;
+  emoji: string;
+  gifs: string;
+  attachFile: string;
+  recordVoice: string;
+  stopRecording: string;
+  stop: string;
+  copy: string;
+  copied: string;
+  retry: string;
+  clearChat: string;
+  clearChatConfirm: string;
+  clearChatConfirmBody: string;
+  clearConfirmCta: string;
+  /** Header "End conversation" button + its confirm dialog + ended-state copy. */
+  endChat: string;
+  endChatConfirm: string;
+  endChatConfirmBody: string;
+  endConfirmCta: string;
+  conversationEnded: string;
+  startNewChat: string;
+  /** Past-conversations history. */
+  pastConversations: string;
+  viewingPast: string;
+  backToChat: string;
+  historyEnded: string;
+  /** Per-message 👍/👎 feedback. */
+  feedbackHelpful: string;
+  feedbackNotHelpful: string;
+  feedbackThanks: string;
+  /** End-of-chat CSAT prompt. */
+  csatPrompt: string;
+  feedbackCommentPlaceholder: string;
+  feedbackSend: string;
+  cancel: string;
+  newMessages: string;
+  poweredBy: string;
+  searchGifs: string;
+  searchingGifs: string;
+  noGifs: string;
+  assistantTyping: string;
+  emptyReply: string;
+  errorGeneric: string;
+  errorRateLimit: string;
+  attaching: string;
+  attachTooLarge: string;
+  attachFailed: string;
+  /** Handoff card (manual follow-up request). */
+  handoffTitle: string;
+  handoffName: string;
+  handoffEmail: string;
+  handoffNotify: string;
+  sending: string;
+  /** Confirmation after a manual submit. `{email}` is replaced with the address (or removed). */
+  handoffShared: string;
+  /** Generic action-form success fallback + error. */
+  formThanks: string;
+  formError: string;
+  /** Demo-booking picker. */
+  bookingPickTime: string;
+  bookingDuration: string;
+  /** Confirmation after requesting a demo. `{when}` = the chosen slot. */
+  bookingRequested: string;
+  /** Confirmation when a real calendar event was created. `{when}` = slot. */
+  bookingConfirmed: string;
+  /** Shown when the chosen slot was just taken by someone else. */
+  bookingSlotTaken: string;
+  /** Link-mode (Calendly): prompt + CTA + done note + the meeting link label.
+   * `{provider}` = the scheduler label (e.g. "Calendly"). */
+  bookingViaProvider: string;
+  bookingOpenScheduler: string;
+  bookingLinkOpened: string;
+  bookingMeetingLink: string;
+  /** Preview mode (data-preview): canned reply, action note, top banner. */
+  previewReply: string;
+  previewActionNote: string;
+  previewBanner: string;
+}
+//#endregion
+//#region src/api/types.d.ts
+/** The result metadata that arrives with (or after) an answer. */
+interface TurnResult {
+  answer: string;
+  sources: Source[];
+  suggestedReplies: string[];
+  availableActions: string[];
+  handoffOffered: boolean;
+  /** Contact fields the backend wants inline before handoff, e.g. ["email"]. */
+  requestedContactFields?: string[];
+  /** True when the backend closed the session (visitor ended it, or 24h idle). */
+  conversationEnded?: boolean;
+  /** Current live handoff state for the session. */
+  liveMode?: 'ai' | 'queued' | 'human';
+  /** Human currently assigned to the chat, when liveMode is human. */
+  assignedAgentName?: string;
+  /** Optional TTS audio for Talkback-enabled assistant replies. */
+  audioBase64?: string;
+  mimeType?: string;
+  visualization?: AnalyticsVisualization;
+}
+interface AnalyticsVisualizationColumn {
+  key: string;
+  label: string;
+  dataType: 'text' | 'number' | 'currency' | 'percent' | 'boolean' | 'date' | 'datetime';
+  semanticRole: 'identifier' | 'dimension' | 'measure' | 'date' | 'geography' | 'boolean';
+  aggregation?: 'none' | 'sum' | 'avg' | 'count' | 'count_distinct' | 'min' | 'max';
+  formatPattern?: string;
+  currencyCode?: string;
+  description?: string;
+  priority?: 'primary' | 'secondary' | 'detail';
+  sortable?: boolean;
+  filterable?: boolean;
+  groupable?: boolean;
+}
+interface AnalyticsVisualizationRecommendation {
+  type: 'kpi' | 'table' | 'line' | 'area' | 'bar' | 'stacked_bar' | 'pie' | 'scatter' | 'funnel';
+  mode: string;
+  categoryField?: string;
+  valueFields?: string[];
+  seriesField?: string;
+  reason?: string;
+  confidence?: number;
+}
+interface AnalyticsVisualizationExplanation {
+  headline: string;
+  summary: string;
+  evidence?: string[];
+  businessMeaning?: string;
+  possibleDrivers?: Array<{
+    hypothesis: string;
+    howToCheck: string;
+  }>;
+  recommendations?: Array<{
+    action: string;
+    why: string;
+    successMetric?: string;
+  }>;
+  forecast?: {
+    text: string;
+    horizon?: string;
+    qualityStatus?: string;
+    limitations?: string;
+  };
+  limitations?: string[];
+  followUps?: string[];
+  source: 'governed_result' | 'ai_grounded';
+}
+interface AnalyticsVisualization {
+  version?: number;
+  presentation?: 'kpi' | 'chart' | 'table';
+  type: 'kpi' | 'table' | 'bar' | 'line' | 'stacked_bar';
+  title?: string;
+  label?: string;
+  value?: string;
+  valueFields?: string[];
+  series?: string;
+  seriesField?: string;
+  columns?: string[];
+  rows?: Array<Record<string, unknown>>;
+  queryRunId?: string;
+  traceId?: string;
+  durationMs?: number;
+  rowCount?: number;
+  truncated?: boolean;
+  timezone?: string;
+  model?: {
+    id?: string;
+    name?: string;
+    version?: number;
+  };
+  freshness?: {
+    status: 'live' | 'stale' | 'unknown';
+    answeredAt?: string;
+  };
+  reportingPeriod?: {
+    label: string;
+    start?: string;
+    end?: string;
+    timezone?: string;
+  };
+  appliedFilters?: Array<{
+    field: string;
+    operator: string;
+    value: unknown;
+  }>;
+  columnMetadata?: AnalyticsVisualizationColumn[];
+  totals?: Record<string, unknown>;
+  currency?: {
+    code?: string;
+    field?: string;
+    source?: 'fixed_metadata' | 'source_field';
+    isMixed: boolean;
+  };
+  chartRecommendation?: AnalyticsVisualizationRecommendation;
+  expandable?: boolean;
+  tableAvailable?: boolean;
+  downloadAvailable?: boolean;
+  explanation?: AnalyticsVisualizationExplanation;
+}
+interface SpeechResult {
+  providerReady: boolean;
+  message?: string;
+  audioBase64?: string;
+  mimeType?: string;
+}
+interface LiveEvent {
+  id: string;
+  type: 'chat' | 'handoff_queued' | 'agent_joined' | 'agent_left' | string;
+  role?: 'assistant' | 'user' | string;
+  content: string;
+  authorName?: string;
+  createdAt: string;
+}
+interface LiveEventsResult {
+  mode: 'ai' | 'queued' | 'human';
+  assignedAgentName?: string;
+  agentTyping?: boolean;
+  agentTypingName?: string;
+  conversationEnded?: boolean;
+  events: LiveEvent[];
+}
+interface StreamCallbacks {
+  /** Called with each incremental text chunk. */
+  onChunk: (text: string) => void;
+  signal?: AbortSignal;
+  /** True only for turns sent from the active Speak-with-AI call. */
+  voicePlaybackRequested?: boolean;
+}
+type ActionType = 'contact' | 'inquiry' | 'book-demo' | 'request-callback' | 'subscribe-newsletter';
+interface ActionResult {
+  ok: boolean;
+  note?: string;
+  /** Present on book-a-demo when a connected scheduler fulfilled it live —
+   * a real calendar event was created (event mode) or a Calendly link was
+   * resolved (link mode). Absent when it fell back to a staff-follow-up request. */
+  booking?: DemoBooking;
+}
+/** Outcome of a live book-a-demo (mirrors backend services.PublicDemoBooking). */
+interface DemoBooking {
+  mode: 'event' | 'link';
+  provider: string;
+  confirmed?: boolean;
+  eventLink?: string;
+  meetingUrl?: string;
+  schedulingLink?: string;
+}
+/** A 👍/👎 a visitor left on one assistant reply (POST /public-chat/feedback). */
+interface FeedbackInput {
+  sessionId: string;
+  /** The widget's local assistant-bubble id — correlates the rating server-side. */
+  messageId: string;
+  rating: 'up' | 'down';
+  /** Optional free text, offered on 👎. */
+  comment?: string;
+  /** Short context so the owner sees WHAT was rated (truncated server-side). */
+  question?: string;
+  answer?: string;
+}
+/** A [start, end) window the org's calendar is busy. */
+interface BusyRange {
+  start: string;
+  end: string;
+}
+/** Booking availability for the picker. */
+interface DemoSlotsResult {
+  /** Exact slot instants (UTC ISO) already booked via the widget. */
+  taken: string[];
+  /** Busy ranges from the connected calendar (Google / Outlook). */
+  busy: BusyRange[];
+}
+interface GifResult {
+  id: string;
+  /** Full GIF URL (what gets sent + rendered). */
+  url: string;
+  /** Smaller preview URL for the picker grid. */
+  preview: string;
+  alt: string;
+}
+/**
+ * Transport abstraction so the UI is identical whether it talks to the real
+ * backend (`ApiClient`) or the in-memory demo (`MockTransport`).
+ */
+interface Transport {
+  bootstrap(): Promise<BootstrapInfo>;
+  /** Stream a turn; resolves with final metadata once `done`. */
+  stream(question: string, sessionId: string, cb: StreamCallbacks): Promise<TurnResult>;
+  /** Poll for staff/system events after a timestamp during live handoff. */
+  liveEvents(sessionId: string, after: string): Promise<LiveEventsResult>;
+  /** Soft visitor typing hint for the staff console. */
+  typing(sessionId: string, isTyping: boolean): Promise<void>;
+  action(type: ActionType, payload: Record<string, unknown>): Promise<ActionResult>;
+  /** Synthesize short widget UI prompts through the token's configured TTS voice. */
+  speak(text: string): Promise<SpeechResult>;
+  transcribe(audioBase64: string, mimeType: string, languageHint?: string, durationSeconds?: number): Promise<string>;
+  /**
+   * Extract text from a visitor-attached image / PDF via the backend's
+   * multimodal endpoint (`POST /public-chat/extract`). The returned text is
+   * prepended to the visitor's next message so the AI can answer about it.
+   * Resolves to '' when extraction is unavailable / fails.
+   */
+  extract(fileBase64: string, mimeType: string, filename?: string): Promise<string>;
+  /** Search GIFs (Tenor). Returns [] when no key is configured. */
+  searchGifs(query: string): Promise<GifResult[]>;
+  /**
+   * Booking availability within [fromISO, toISO]: `taken` = exact slot instants
+   * already booked via the widget; `busy` = ranges the connected calendar
+   * (Google / Outlook) is occupied. The picker greys out both. Best-effort —
+   * empty when unavailable (the picker then shows everything as open).
+   */
+  demoSlots(fromISO: string, toISO: string): Promise<DemoSlotsResult>;
+  /**
+   * Host-app SSO passthrough. Backend `POST /public-chat/identify`.
+   * Best-effort: failures are swallowed; identify never blocks chat
+   * (per .claude/PUBLIC_CHAT.md "Identified visitors").
+   */
+  identify(sessionId: string, user: WidgetUser): Promise<void>;
+  /** End the conversation (`POST /public-chat/end`) — the backend then rejects
+   * further turns until the visitor starts a new one. Best-effort. */
+  endConversation(sessionId: string): Promise<void>;
+  /** Record a 👍/👎 on an assistant reply (`POST /public-chat/feedback`).
+   * Best-effort — a failed rating never disrupts the chat. */
+  sendFeedback(input: FeedbackInput): Promise<void>;
+}
+//#endregion
+//#region src/types.d.ts
+/** Public configuration surface passed to `Centrinfo.init()` / <CentrinfoWidget>. */
+interface WidgetConfig {
+  /** The org's public chat token (`pub_*`). Required. It IS the org identity. */
+  token: string;
+  /** Short-lived server-signed context token for governed customer analytics. */
+  analyticsContextToken?: string;
+  /** Short-lived SDK customer identity JWT for authenticated chat access. */
+  identityToken?: string;
+  /** Refreshes the customer identity JWT before an authenticated chat turn. */
+  getIdentityToken?: () => string | Promise<string>;
+  /** API origin. Defaults to the production Centrinfo API. */
+  apiBaseUrl?: string;
+  /** Brand accent (any CSS color). Overrides the persona/default green. */
+  accentColor?: string;
+  /** Optional display-name override. Normally loaded from the token bootstrap. */
+  agentName?: string;
+  /** Optional header avatar URL override. Normally loaded from the token bootstrap. */
+  agentAvatarUrl?: string;
+  /** Custom launcher icon — an image URL (e.g. the org's logo). Defaults to a chat glyph. */
+  launcherIcon?: string;
+  /** Tenor API key — enables the GIF picker. Omit to hide the GIF button. */
+  gifApiKey?: string;
+  /** Force a theme; otherwise follows the host's `prefers-color-scheme`. */
+  theme?: 'light' | 'dark' | 'auto';
+  /** Open the panel automatically on first load. */
+  openByDefault?: boolean;
+  /** Play subtle sound effects (open / send / receive). Default true. Visitors can still mute. */
+  sound?: boolean;
+  /**
+   * Tappable example questions shown under the greeting until the visitor
+   * sends their first message. When omitted, the widget falls back to the
+   * `starterQuestions` configured on the token (served by bootstrap).
+   */
+  starters?: string[];
+  /**
+   * Localise the UI chrome. Any subset of `WidgetStrings` is merged over the
+   * English defaults — pass e.g. `{ composerPlaceholder: 'Écrivez…' }`. The
+   * chat answers themselves are already multilingual server-side.
+   */
+  labels?: Partial<WidgetStrings>;
+  /**
+   * Where the visible transcript is stored across reloads:
+   * - `local` (default) — `localStorage`, survives browser restarts (30d TTL).
+   * - `session` — `sessionStorage`, cleared when the tab closes (better on
+   *   shared / kiosk machines so the next visitor can't read prior chats).
+   * - `none` — never persisted; the transcript lives only in memory.
+   * The backend session id + memory are unaffected — this is purely the
+   * locally-rendered history.
+   */
+  persistence?: 'local' | 'session' | 'none';
+  /**
+   * Let visitors attach an image / PDF for the assistant to read (extracted
+   * server-side via the multimodal endpoint). Default true; set false to hide
+   * the attach button entirely.
+   */
+  attachments?: boolean;
+  /** Stacking context against the host page. */
+  zIndex?: number;
+  /** Use the built-in mock transport (local preview, no backend/token needed). */
+  demo?: boolean;
+  /**
+   * Preview mode. Loads the widget's REAL branding (via the bootstrap read)
+   * but answers every chat with a canned sample reply instead of calling the
+   * AI — so a developer can test the integration anywhere with just the token,
+   * at zero AI cost. Remove this flag (or use the normal embed) to go live.
+   */
+  preview?: boolean;
+  /**
+   * Host-app SSO passthrough. When the embedding site has a logged-in
+   * user, pass their identity here so the chat session is correlated
+   * with them in the org's widget inbox (instead of showing as
+   * "Anonymous"). Fully optional — omit for unauthenticated visitors.
+   *
+   * The widget posts this to `POST /public-chat/identify` once after
+   * bootstrap completes. To identify a visitor who logs in MID-SESSION
+   * (anonymous chat → sign-in), call `handle.identify(user)` instead.
+   * The same `sessionId` survives the identify call, so prior
+   * anonymous messages stay attached to the now-known session row.
+   *
+   * See .claude/PUBLIC_WIDGET_LIBRARY.md "Identified visitors" for
+   * what fields to pass + the privacy guidance.
+   */
+  user?: WidgetUser;
+  /** Which side the launcher + panel dock to. Default 'right'. */
+  alignment?: 'left' | 'right';
+  /** Horizontal distance (px) from the aligned edge. Default 20. */
+  horizontalPadding?: number;
+  /** Vertical distance (px) from the bottom. Default 20. */
+  verticalPadding?: number;
+  /** Hide the built-in launcher button — open the widget via `show()` or a
+   * `customLauncherSelector`. Default false. */
+  hideDefaultLauncher?: boolean;
+  /** CSS selector for host-page element(s) that open the widget on click
+   * (your own launcher). Listeners are (re)bound automatically. */
+  customLauncherSelector?: string;
+  /** Auto-logout (wipe local data) after this many minutes of inactivity.
+   * 0 / omitted = never. Use on shared / kiosk devices. */
+  sessionDurationMinutes?: number;
+  /**
+   * How often the open widget refreshes its public token configuration
+   * (branding, greeting, starter questions, allowed actions, pause/offline
+   * state) from `/public-chat/bootstrap`. Default 30 seconds; set 0 to
+   * disable live config refresh for strict traffic budgets.
+   */
+  configRefreshSeconds?: number;
+  /** A message to proactively show (auto-opens the widget) — e.g.
+   * "Questions about pricing? I'm here 👋". Omit to disable. */
+  proactiveMessage?: string;
+  /** Seconds to wait on the page before showing it. Default 5. */
+  proactiveDelaySeconds?: number;
+  /** Only fire on pages whose path contains one of these substrings.
+   * Omitted/empty = every page. e.g. ['/pricing', '/checkout']. */
+  proactiveOnPaths?: string[];
+  /** Show a "How was this chat?" CSAT rating when the conversation ends.
+   * Default true. */
+  csat?: boolean;
+  /** Event hooks. */
+  onOpen?: () => void;
+  onClose?: () => void;
+  /** Aliases of onOpen/onClose (Intercom naming). Both fire. */
+  onShow?: () => void;
+  onHide?: () => void;
+  /** Fires whenever the unread-message count changes (drive your own badge). */
+  onUnreadChange?: (count: number) => void;
+  onMessage?: (msg: {
+    role: 'user' | 'assistant';
+    content: string;
+  }) => void;
+  onAction?: (action: string) => void;
+  onHandoff?: () => void;
+}
+/** A B2B company / account the visitor belongs to (Intercom "Company object").
+ * Folded into the session metadata for the staff inbox. */
+interface WidgetCompany {
+  id?: string;
+  name?: string;
+  plan?: string;
+  /** Account creation date — epoch seconds/ms or ISO string. */
+  createdAt?: number | string;
+  monthlySpend?: number;
+  /** Any extra company attributes. */
+  [key: string]: string | number | boolean | undefined;
+}
+/** Host-app SSO passthrough payload + data attributes. All fields optional. */
+interface WidgetUser {
+  /** Host-app's stable user id (UUID, account number, etc.). Strongly recommended. */
+  externalId?: string;
+  /** Intercom-style alias for `externalId` (whichever you set is used). */
+  userId?: string;
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  /** Single-field name when first/last aren't split host-side. */
+  name?: string;
+  phone?: string;
+  /** Account creation date — epoch seconds/ms or ISO string (a data attribute). */
+  createdAt?: number | string;
+  /** Avatar image URL (the "Avatar object") — surfaced to staff in the inbox. */
+  avatarUrl?: string;
+  /** The visitor's company / account (B2B "Company object"). */
+  company?: WidgetCompany;
+  /**
+   * Custom data attributes (plan tier, signup date, segment, …). Merged into
+   * the session metadata, same privacy caveat as `metadata` below.
+   */
+  customAttributes?: Record<string, string | number | boolean>;
+  /**
+   * Arbitrary host-app key/values (plan tier, signup date, custom
+   * segments). Surfaced as-is in the org's staff inbox. DO NOT pass
+   * sensitive data — the widget script runs on the public web and a
+   * determined visitor with devtools could inspect it. Safe: plan
+   * tier, signup date, segment. Unsafe: card numbers, SSNs, auth
+   * tokens, internal admin flags.
+   */
+  metadata?: Record<string, string | number | boolean>;
+}
+/** Imperative handle returned by `init()` / `createWidget()`. */
+interface WidgetHandle {
+  open: () => void;
+  close: () => void;
+  toggle: () => void;
+  /** Open the panel (alias of `open`, Intercom naming). */
+  show: () => void;
+  /** Close the panel (alias of `close`, Intercom naming). */
+  hide: () => void;
+  /** Update the visitor's attributes mid-session (merge). Alias of `identify`. */
+  update: (user: WidgetUser) => void;
+  /**
+   * Identify the visitor mid-session (e.g. after they log in on the
+   * host site). The session's prior anonymous messages stay attached
+   * — the widget's sessionId is stable across identify. Same merge
+   * semantics as boot-time `user`: first-value-wins per field, shallow
+   * metadata merge.
+   */
+  identify: (user: WidgetUser) => void;
+  /** Wipe the locally-rendered transcript + start a fresh backend session. */
+  clear: () => void;
+  /**
+   * Logout: erase ALL of this visitor's locally-stored data (identity,
+   * transcripts, conversation history) and reset to a fresh anonymous
+   * session. Call on host-app logout / shared devices — à la Intercom
+   * `shutdown`. `logout` is an alias.
+   */
+  shutdown: () => void;
+  logout: () => void;
+  destroy: () => void;
+}
+/** A rendered chat message. */
+interface ChatMessage {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  /** Human name for live agent replies or system join/leave events. */
+  authorName?: string;
+  /** Live handoff event type from the backend, e.g. agent_joined. */
+  liveEventType?: string;
+  /** ISO timestamp for server-originated live events. */
+  createdAt?: string;
+  /** Inline image (e.g. a GIF the visitor sent). Rendered in the bubble. */
+  imageUrl?: string;
+  /** Name of a file the visitor attached (rendered as a chip on their bubble). */
+  attachmentName?: string;
+  sources?: Source[];
+  suggestedReplies?: string[];
+  availableActions?: string[];
+  handoffOffered?: boolean;
+  /** Contact fields requested by final API metadata before handoff. */
+  requestedContactFields?: string[];
+  /** Assistant message awaiting its first token (shows the typing dots). */
+  pending?: boolean;
+  /** Assistant message actively streaming tokens in (shows the live caret). */
+  streaming?: boolean;
+  /** Something went wrong producing this turn. */
+  error?: boolean;
+  /** On an errored turn, the question to re-send when the visitor taps Retry. */
+  retryText?: string;
+  /** Visitor's 👍/👎 on this assistant reply (persisted so it survives reloads). */
+  feedback?: 'up' | 'down';
+  visualization?: AnalyticsVisualization;
+}
+interface Source {
+  title?: string;
+  url?: string;
+}
+interface FeaturedLink {
+  label: string;
+  url: string;
+}
+/** Visitor identity captured progressively across the chat (persisted locally). */
+interface Visitor {
+  name?: string;
+  email?: string;
+  phone?: string;
+}
+/** Persona + capabilities returned by `GET /public-chat/bootstrap`. */
+interface BootstrapInfo {
+  agentName: string;
+  agentAvatarUrl?: string;
+  greeting: string;
+  /** Public module selected on the token: classic chat or assistant card. */
+  widgetModule?: 'chat' | 'assistant';
+  /** Assistant-card hero media. Video is rendered muted/looping. */
+  assistantMediaUrl?: string;
+  assistantMediaKind?: 'image' | 'video';
+  assistantPrivacyUrl?: string;
+  /** Org-token default for widget sounds. Visitors can still mute locally. */
+  soundEnabled?: boolean;
+  /** TTS output preference. Synthesis is not wired in the SDK yet. */
+  voiceOutputEnabled?: boolean;
+  voiceProvider?: string;
+  voiceId?: string;
+  voiceSpeed?: number;
+  /** Visitor reply experience: text, spoken voice, or spoken voice with avatar. */
+  talkbackMode?: 'text' | 'voice' | 'avatar';
+  avatarProvider?: string;
+  avatarId?: string;
+  allowVoiceInput: boolean;
+  /**
+   * Token memory controls from the dashboard. Backend memory gates AI context;
+   * the SDK mirrors the same switch for locally-rendered transcript history.
+   */
+  memoryEnabled: boolean;
+  memoryRetentionDays: number;
+  memoryMessageCap: number;
+  availableActions: string[];
+  accentColor?: string;
+  /** One-line description under the agent name on the welcome screen (≤500). */
+  agentDescription?: string;
+  /** Small subtitle under the greeting (≤160). */
+  welcomeSubtitle?: string;
+  /** Fine-print shown under the composer (≤500). */
+  disclaimerText?: string;
+  /** Token-configured starter prompts; used when the host didn't pass `starters`. */
+  starterQuestions?: string[];
+  /** Token-configured manual links shown before the visitor sends a message. */
+  featuredLinks?: FeaturedLink[];
+  /** True when bootstrap was loaded in the org's offline window. */
+  offline?: boolean;
+  /** Book-a-demo scheduler status (present only when book-a-demo is enabled).
+   * Drives the demo UX: event-mode → in-widget slot picker that creates a real
+   * calendar event; link-mode → a "Book on Calendly" link; absent/!connected →
+   * slot picker that just files a request for staff to confirm. */
+  scheduler?: SchedulerInfo;
+}
+/** Connected book-a-demo scheduler (mirrors backend services.PublicSchedulerInfo). */
+interface SchedulerInfo {
+  connected: boolean;
+  provider?: string;
+  label?: string;
+  mode?: 'event' | 'link';
+  bookingLink?: string;
+}
+//#endregion
+export { Visitor as a, WidgetUser as c, AnalyticsVisualization as d, DemoSlotsResult as f, WidgetStrings as h, Source as i, ActionResult as l, Transport as m, ChatMessage as n, WidgetConfig as o, GifResult as p, FeaturedLink as r, WidgetHandle as s, BootstrapInfo as t, ActionType as u };