@enjoys/react-chatbot-plugin 1.8.2 → 1.23.0

package/dist/index.d.ts

@@ -76,6 +76,50 @@ export declare function autoReplyPlugin(options?: {
     onlyWhenOpen?: boolean;
 }): ChatPlugin;
 
+declare interface BookingConfirmation {
+    bookingId: string;
+    date: string;
+    time: string;
+    status: 'confirmed' | 'pending' | 'cancelled';
+}
+
+export declare function bookingPlugin(options: BookingPluginOptions): ChatPlugin;
+
+declare interface BookingPluginOptions {
+    /** API endpoint to fetch available slots (GET ?date=YYYY-MM-DD) */
+    slotsEndpoint: string;
+    /** API endpoint to confirm booking (POST) */
+    bookEndpoint: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Callback on successful booking */
+    onBooked?: (confirmation: BookingConfirmation) => void;
+    /** Callback on cancelled booking */
+    onCancelled?: (bookingId: string) => void;
+    /** Flow step after booking confirmed */
+    successStep?: string;
+    /** Custom message format for available slots */
+    slotsMessage?: (slots: TimeSlot[]) => string;
+}
+
+declare interface BotPersona {
+    /** Unique persona identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Greeting message when switching to this persona */
+    greeting?: string;
+    /** Theme overrides */
+    theme?: {
+        primaryColor?: string;
+        headerBg?: string;
+    };
+    /** Flow config ID to activate */
+    flowId?: string;
+}
+
 export declare const Branding: default_2.FC<BrandingProps>;
 
 export declare interface BrandingConfig {
@@ -124,6 +168,23 @@ export declare function campaignPlugin(options: {
     onTrigger?: (campaign: CampaignConfig, ctx: PluginContext) => void;
 }): ChatPlugin;
 
+declare interface CardButton {
+    label: string;
+    /** Quick reply value — triggers onQuickReply */
+    value?: string;
+    /** URL to open in a new tab */
+    url?: string;
+    /** Flow step to jump to */
+    next?: string;
+}
+
+declare interface CarouselCard {
+    title: string;
+    subtitle?: string;
+    image?: string;
+    buttons?: CardButton[];
+}
+
 declare type ChatAction = {
     type: 'TOGGLE_OPEN';
 } | {
@@ -187,6 +248,25 @@ export declare interface ChatBotProps {
     zIndex?: number;
     /** Enable emoji picker */
     enableEmoji?: boolean;
+    /** Enable message reactions (👍👎 on bot/agent messages).
+     *  Pass `true` for default emojis, or an array of custom emoji strings. */
+    enableReactions?: boolean | string[];
+    /** Enable message search — adds a search icon in the header */
+    enableSearch?: boolean;
+    /** Enable voice input (speech-to-text) via Web Speech API */
+    enableVoice?: boolean | {
+        lang?: string;
+        continuous?: boolean;
+    };
+    /** Show "User is typing..." to the bot/agent side — emits typing events */
+    showUserTyping?: boolean;
+    /** Allow user to edit/delete their sent messages */
+    allowMessageEdit?: boolean;
+    /** Show read receipt indicators (✓ sent, ✓✓ delivered, ✓✓ read) */
+    showReadReceipts?: boolean;
+    /** Enable built-in markdown rendering in messages (bold, italic, code, links, lists).
+     *  Pass `true` for all features, or an options object to selectively enable. */
+    markdown?: boolean | MarkdownOptions;
     /** File upload configuration */
     fileUpload?: FileUploadConfig;
     /** Map of custom components that can be rendered in flow steps (key = step.component) */
@@ -209,6 +289,10 @@ export declare interface ChatBotProps {
     icons?: Partial<ChatIconMap>;
     /** Live agent configuration — WebSocket or Socket.IO real-time chat with human agents */
     liveAgent?: LiveAgentConfig;
+    /** Middleware pipeline — functions that intercept/transform messages before processing */
+    middleware?: FlowMiddleware[];
+    /** Headless mode — hides all UI, exposes only the engine & plugin system via ref */
+    headless?: boolean;
 }
 
 export declare const ChatBubbleIcon: default_2.FC<IconProps>;
@@ -226,6 +310,10 @@ export declare interface ChatCallbacks {
     onFlowEnd?: (collectedData: Record<string, unknown>) => void;
     onError?: (error: Error) => void;
     onEvent?: (event: string, payload?: unknown) => void;
+    /** Called when user reacts to a message */
+    onReaction?: (messageId: string, emoji: string, reacted: boolean) => void;
+    /** Called when user starts/stops typing */
+    onUserTyping?: (isTyping: boolean) => void;
     /** Called when user types text the bot couldn't handle */
     onUnhandledMessage?: (text: string, context: {
         currentStepId: string | null;
@@ -285,11 +373,12 @@ declare interface ChatHeaderProps {
     onRestart?: () => void;
     logo?: string;
     logoWidth?: string;
+    onSearchChange?: (query: string) => void;
 }
 
 /** Map of all replaceable icons. Each value is a `ReactNode` so users can
  *  supply any JSX element (SVG, image, icon-library component, etc.). */
-declare interface ChatIconMap {
+export declare interface ChatIconMap {
     send: ReactNode;
     chatBubble: ReactNode;
     close: ReactNode;
@@ -300,6 +389,11 @@ declare interface ChatIconMap {
     image: ReactNode;
     remove: ReactNode;
     restart: ReactNode;
+    search: ReactNode;
+    mic: ReactNode;
+    star: ReactNode;
+    edit: ReactNode;
+    trash: ReactNode;
 }
 
 export declare const ChatInput: default_2.FC<ChatInputProps>;
@@ -330,6 +424,12 @@ export declare interface ChatMessage {
     component?: string;
     /** Agent name for live agent messages */
     agentName?: string;
+    /** Carousel cards — renders horizontally scrollable rich cards */
+    cards?: CarouselCard[];
+    /** Reactions on this message */
+    reactions?: MessageReaction[];
+    /** Message delivery status */
+    status?: MessageStatus;
 }
 
 export declare interface ChatPlugin {
@@ -448,6 +548,19 @@ export declare interface CheckboxFieldRenderProps {
 
 export declare const CloseIcon: default_2.FC<IconProps>;
 
+export declare function codeHighlightPlugin(options?: CodeHighlightPluginOptions): ChatPlugin;
+
+declare interface CodeHighlightPluginOptions {
+    /** Theme: 'dark' | 'light' (default: 'dark') — applies CSS class */
+    theme?: 'dark' | 'light';
+    /** Add copy button to code blocks (default: true) */
+    copyButton?: boolean;
+    /** Max height for code blocks in px (default: 300) */
+    maxHeight?: number;
+    /** Languages to auto-detect (informational) */
+    languages?: string[];
+}
+
 /**
  * Component Plugin — injects custom component messages into chat via events
  */
@@ -456,6 +569,56 @@ export declare function componentPlugin(options?: {
     onRender?: (componentKey: string, ctx: PluginContext) => void;
 }): ChatPlugin;
 
+export declare function confettiPlugin(options?: ConfettiPluginOptions): ChatPlugin;
+
+declare interface ConfettiPluginOptions {
+    /** Events that auto-trigger confetti (default: ['flowEnd']) */
+    triggers?: string[];
+    /** Duration in ms (default: 3000) */
+    duration?: number;
+    /** Number of particles (default: 50) */
+    particleCount?: number;
+    /** Custom colors */
+    colors?: string[];
+    /** Callback when confetti fires */
+    onFire?: () => void;
+}
+
+declare type ConversationPriority = 'low' | 'medium' | 'high' | 'urgent';
+
+/**
+ * Create a standalone event bus instance.
+ *
+ * @example
+ * ```ts
+ * import { createEventBus } from '@enjoys/react-chatbot-plugin';
+ *
+ * const bus = createEventBus();
+ * bus.on('user:login', (data) => console.log(data));
+ * bus.emit('user:login', { name: 'Alice' });
+ * ```
+ */
+export declare function createEventBus(): EventBus;
+
+/**
+ * Create a headless chatbot instance (no UI).
+ *
+ * @example
+ * ```ts
+ * import { createHeadlessBot } from '@enjoys/react-chatbot-plugin';
+ *
+ * const bot = createHeadlessBot({
+ *   flow: myFlow,
+ *   plugins: [loggerPlugin()],
+ *   onMessage: (msg) => console.log(msg.sender, msg.text),
+ * });
+ *
+ * await bot.sendMessage('hello');
+ * console.log(bot.getMessages());
+ * ```
+ */
+export declare function createHeadlessBot(options?: HeadlessBotOptions): HeadlessBot;
+
 /**
  * CRM Plugin — pushes user/lead data to CRM systems
  */
@@ -530,6 +693,21 @@ declare interface EmojiPickerProps {
     primaryColor: string;
 }
 
+export declare interface EventBus {
+    /** Subscribe to an event */
+    on(event: string, handler: EventHandler): () => void;
+    /** Subscribe once — auto-removes after first call */
+    once(event: string, handler: EventHandler): () => void;
+    /** Emit an event to all subscribers */
+    emit(event: string, ...args: unknown[]): void;
+    /** Remove a specific handler */
+    off(event: string, handler: EventHandler): void;
+    /** Remove all handlers for an event (or all events if no event specified) */
+    clear(event?: string): void;
+}
+
+export declare type EventHandler = (...args: unknown[]) => void;
+
 /** Props passed to file custom field renderers */
 export declare interface FileFieldRenderProps {
     type: 'file';
@@ -646,6 +824,10 @@ export declare class FlowEngine {
     /** Reset the engine to initial state */
     reset(): void;
     resolveNext(step: FlowStep, userValue?: string): string | undefined;
+    /** Check if a step should be visible based on its `visibleIf` condition */
+    isStepVisible(step: FlowStep): boolean;
+    /** Resolve a sub-flow's start step (for flow composition) */
+    getSubFlowStartStep(step: FlowStep): FlowStep | undefined;
     /** Returns true if the step expects a quick reply (not free text) */
     stepExpectsQuickReply(step: FlowStep): boolean;
     /** Returns true if the step expects a form submission */
@@ -656,6 +838,9 @@ export declare class FlowEngine {
     private evaluate;
 }
 
+/** Middleware function — can transform messages or short-circuit */
+export declare type FlowMiddleware = (message: ChatMessage, data: Record<string, unknown>, next: () => void) => void | ChatMessage;
+
 export declare interface FlowQuickReply {
     label: string;
     value: string;
@@ -679,6 +864,12 @@ export declare interface FlowStep {
     input?: FlowStepInput;
     /** Async action to run when this step is entered (API calls, verification, etc.) */
     asyncAction?: FlowAsyncAction;
+    /** Only show this step when condition is met (conditional rendering) */
+    visibleIf?: FlowCondition;
+    /** Sub-flow composition — inline another flow's steps */
+    subFlow?: FlowConfig;
+    /** Step to go to after sub-flow completes */
+    onSubFlowComplete?: string;
 }
 
 /** Configuration for a free-text input step with optional validation */
@@ -738,7 +929,7 @@ export declare type FormFieldRenderMap = Partial<{
 /** Union of all field render props — discriminated by `type` */
 export declare type FormFieldRenderProps = TextFieldRenderProps | SelectFieldRenderProps | RadioFieldRenderProps | CheckboxFieldRenderProps | FileFieldRenderProps;
 
-export declare type FormFieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'textarea' | 'select' | 'multiselect' | 'radio' | 'checkbox' | 'file' | 'date' | 'time' | 'hidden';
+export declare type FormFieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'textarea' | 'select' | 'multiselect' | 'radio' | 'checkbox' | 'file' | 'date' | 'time' | 'datetime' | 'color' | 'range' | 'hidden';
 
 export declare interface FormFieldValidation {
     required?: boolean;
@@ -774,6 +965,36 @@ export declare interface HeaderSlotProps {
     component?: ReactNode;
 }
 
+export declare interface HeadlessBot {
+    /** Send a user message into the bot */
+    sendMessage: (text: string) => Promise<void>;
+    /** Programmatically add a bot message */
+    addBotMessage: (text: string) => void;
+    /** Get all messages in the conversation */
+    getMessages: () => ChatMessage[];
+    /** Get collected data */
+    getData: () => Record<string, unknown>;
+    /** Set a data field */
+    setData: (key: string, value: unknown) => void;
+    /** Get the current step ID (null if no flow) */
+    getCurrentStep: () => string | null;
+    /** Go to a specific flow step */
+    goToStep: (stepId: string) => Promise<void>;
+    /** Reset the bot state */
+    reset: () => void;
+    /** The event bus for this instance */
+    bus: EventBus;
+    /** Destroy the bot — cleans up plugins */
+    destroy: () => Promise<void>;
+}
+
+export declare interface HeadlessBotOptions {
+    flow?: FlowConfig;
+    plugins?: ChatPlugin[];
+    initialMessages?: ChatMessage[];
+    onMessage?: (message: ChatMessage) => void;
+}
+
 /**
  * i18n Plugin — supports multiple languages with dynamic switching
  */
@@ -822,6 +1043,14 @@ declare interface IntentRule {
     matchType?: 'contains' | 'exact' | 'regex';
 }
 
+declare interface KBArticle {
+    id: string;
+    title: string;
+    content: string;
+    tags?: string[];
+    url?: string;
+}
+
 /** Route configuration for keyword-based text matching */
 export declare interface KeywordRoute {
     /** Patterns to match against user text */
@@ -838,6 +1067,25 @@ export declare interface KeywordRoute {
     priority?: number;
 }
 
+export declare function knowledgeBasePlugin(options?: KnowledgeBasePluginOptions): ChatPlugin;
+
+declare interface KnowledgeBasePluginOptions {
+    /** Local articles for fuzzy search */
+    articles?: KBArticle[];
+    /** Remote search endpoint (GET with ?q= param) */
+    endpoint?: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Auto-search user messages against KB (default: false) */
+    autoSearch?: boolean;
+    /** Minimum confidence to show result (0-1, default: 0.3) */
+    threshold?: number;
+    /** Max results to show (default: 3) */
+    maxResults?: number;
+    /** Callback on search result */
+    onResult?: (articles: KBArticle[]) => void;
+}
+
 export declare const Launcher: default_2.FC<LauncherProps>;
 
 declare interface LauncherProps {
@@ -973,6 +1221,21 @@ export declare interface LiveAgentEvents {
  */
 export declare function liveAgentPlugin(config: LiveAgentConfig): ChatPlugin;
 
+export declare function locationPlugin(options?: LocationPluginOptions): ChatPlugin;
+
+declare interface LocationPluginOptions {
+    /** Map provider for link generation (default: 'google') */
+    mapProvider?: 'google' | 'openstreetmap' | 'apple';
+    /** High accuracy GPS (default: false) */
+    highAccuracy?: boolean;
+    /** Timeout in ms (default: 10000) */
+    timeout?: number;
+    /** Callback with location data */
+    onLocation?: (lat: number, lng: number) => void;
+    /** Custom message format */
+    messageFormat?: (lat: number, lng: number, url: string) => string;
+}
+
 /**
  * Logger Plugin — logs all chatbot events for debugging or auditing
  */
@@ -1003,6 +1266,23 @@ export declare interface LoginScreenSlotProps {
 
 declare type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 
+export declare interface MarkdownOptions {
+    /** Render **bold** and __bold__ (default: true) */
+    bold?: boolean;
+    /** Render *italic* and _italic_ (default: true) */
+    italic?: boolean;
+    /** Render `inline code` and ```code blocks``` (default: true) */
+    code?: boolean;
+    /** Render [text](url) as links (default: true) */
+    links?: boolean;
+    /** Render - / * / • list items (default: true) */
+    lists?: boolean;
+    /** Render ~~strikethrough~~ (default: true) */
+    strikethrough?: boolean;
+    /** Render headings # ## ### (default: false) */
+    headings?: boolean;
+}
+
 /**
  * Markdown Plugin — transforms markdown syntax in bot messages to HTML
  * Lightweight built-in renderer, no external dependencies.
@@ -1071,12 +1351,95 @@ declare interface MessageListProps {
     renderFormField?: FormFieldRenderMap;
     /** Slot overrides from customizeChat */
     customizeChat?: ChatCustomizeChat;
+    /** Search filter query */
+    searchQuery?: string;
+}
+
+declare interface MessageReaction {
+    emoji: string;
+    count: number;
+    reacted: boolean;
+}
+
+export declare function messageSchedulePlugin(options?: MessageSchedulePluginOptions): ChatPlugin;
+
+declare interface MessageSchedulePluginOptions {
+    /** Polling interval in ms (default: 1000) */
+    checkInterval?: number;
+    /** Max scheduled messages (default: 20) */
+    maxScheduled?: number;
+    /** Persist in localStorage */
+    persist?: boolean;
+    /** Storage key */
+    storageKey?: string;
+    /** Callback when a scheduled message fires */
+    onFire?: (msg: ScheduledMessage_2) => void;
 }
 
 export declare type MessageSender = 'bot' | 'user' | 'system' | 'agent';
 
+declare type MessageStatus = 'sent' | 'delivered' | 'read';
+
 export declare const MinimizeIcon: default_2.FC<IconProps>;
 
+export declare function notificationBadgePlugin(options?: NotificationBadgePluginOptions): ChatPlugin;
+
+declare interface NotificationBadgePluginOptions {
+    /** Play sound on new message (default: false) */
+    playSound?: boolean;
+    /** Sound URL */
+    soundUrl?: string;
+    /** Show browser notification (default: false) */
+    browserNotification?: boolean;
+    /** Update document.title with count (default: false) */
+    updateTitle?: boolean;
+    /** Original page title */
+    originalTitle?: string;
+}
+
+/**
+ * Offline Plugin — queues messages when device is offline and sends them on reconnect.
+ */
+export declare function offlinePlugin(options?: {
+    /** Storage key for queued messages (default: 'cb_offline_queue') */
+    storageKey?: string;
+    /** Show indicator when offline */
+    showOfflineIndicator?: boolean;
+    /** Called when messages are flushed on reconnect */
+    onFlush?: (count: number) => void;
+}): ChatPlugin;
+
+export declare function paymentPlugin(options: PaymentPluginOptions): ChatPlugin;
+
+declare interface PaymentPluginOptions {
+    /** Payment gateway: 'stripe' | 'razorpay' | 'custom' */
+    gateway: 'stripe' | 'razorpay' | 'custom';
+    /** API endpoint for creating payment intent/order */
+    endpoint: string;
+    /** Request headers (API keys etc.) */
+    headers?: Record<string, string>;
+    /** Stripe publishable key (if gateway = 'stripe') */
+    stripeKey?: string;
+    /** Razorpay key ID (if gateway = 'razorpay') */
+    razorpayKey?: string;
+    /** Callback on successful payment */
+    onSuccess?: (result: PaymentResult) => void;
+    /** Callback on failed payment */
+    onError?: (error: string) => void;
+    /** Flow step to go to on success */
+    successStep?: string;
+    /** Flow step to go to on failure */
+    errorStep?: string;
+}
+
+declare interface PaymentResult {
+    success: boolean;
+    transactionId?: string;
+    error?: string;
+    amount: number;
+    currency: string;
+}
+
 /**
  * Persistence Plugin — saves/restores full chat history via browser storage
  */
@@ -1087,6 +1450,35 @@ export declare function persistencePlugin(options?: {
     ttl?: number;
 }): ChatPlugin;
 
+/**
+ * Persona Plugin — switch between different bot personalities in one widget.
+ * Each persona has a name, avatar, greeting, and optionally a different theme/flow.
+ */
+export declare function personaPlugin(options: {
+    personas: BotPersona[];
+    /** Default persona ID (defaults to first) */
+    defaultPersona?: string;
+    /** Storage key for current persona (default: 'cb_persona') */
+    storageKey?: string;
+    /** Called when persona switches */
+    onSwitch?: (persona: BotPersona) => void;
+}): ChatPlugin;
+
+export declare function pinPlugin(options?: PinPluginOptions): ChatPlugin;
+
+declare interface PinPluginOptions {
+    /** Max pinned messages (default: 10) */
+    maxPins?: number;
+    /** Persist pins in localStorage */
+    persist?: boolean;
+    /** Storage key */
+    storageKey?: string;
+    /** Callback when a message is pinned */
+    onPin?: (messageId: string) => void;
+    /** Callback when a message is unpinned */
+    onUnpin?: (messageId: string) => void;
+}
+
 export declare interface PluginContext {
     /** Send a message programmatically */
     sendMessage: (text: string) => void;
@@ -1126,6 +1518,66 @@ export declare class PluginManager {
     private dispatchEvent;
 }
 
+export declare function pollPlugin(options?: PollPluginOptions): ChatPlugin;
+
+declare interface PollPluginOptions {
+    /** Callback when vote is cast */
+    onVote?: (pollId: string, value: string) => void;
+    /** Callback when poll closes */
+    onClose?: (result: PollResult) => void;
+    /** Webhook to report results */
+    webhookUrl?: string;
+}
+
+declare interface PollResult {
+    pollId: string;
+    votes: Record<string, number>;
+    totalVotes: number;
+    userVote?: string | string[];
+}
+
+export declare function priorityPlugin(options?: PriorityPluginOptions): ChatPlugin;
+
+declare interface PriorityPluginOptions {
+    /** Default priority (default: 'medium') */
+    defaultPriority?: ConversationPriority;
+    /** Max labels per conversation (default: 5) */
+    maxLabels?: number;
+    /** Persist in localStorage */
+    persist?: boolean;
+    /** Storage key */
+    storageKey?: string;
+    /** Callback on priority change */
+    onPriorityChange?: (priority: ConversationPriority) => void;
+    /** Callback on label change */
+    onLabelsChange?: (labels: string[]) => void;
+    /** Webhook URL to notify on priority change */
+    webhookUrl?: string;
+}
+
+/**
+ * Proactive Plugin — triggers bot messages based on user behavior.
+ * Supports: idle, scroll depth, exit intent, page load, custom events.
+ */
+export declare function proactivePlugin(options: {
+    rules: ProactiveRule[];
+    /** Called when a proactive message is triggered */
+    onTrigger?: (rule: ProactiveRule) => void;
+}): ChatPlugin;
+
+declare interface ProactiveRule {
+    /** Trigger type */
+    trigger: 'idle' | 'scroll' | 'exitIntent' | 'pageLoad' | 'custom';
+    /** Message to show */
+    message: string;
+    /** Delay in ms before showing (default: 5000) */
+    delay?: number;
+    /** Max number of times to show (default: 1) */
+    maxShows?: number;
+    /** Jump to flow step when user clicks */
+    flowStep?: string;
+}
+
 /**
  * Push Plugin — sends browser push notifications for new messages
  */
@@ -1185,6 +1637,25 @@ export declare function rateLimitPlugin(options?: {
     warningMessage?: string;
 }): ChatPlugin;
 
+/**
+ * Rating Plugin — shows a satisfaction survey at end of conversation.
+ * Triggered on flow end or agent disconnect.
+ */
+export declare function ratingPlugin(options?: {
+    /** Rating scale (default: 5) */
+    scale?: number;
+    /** Prompt text shown to user */
+    prompt?: string;
+    /** Trigger events that show the rating (default: ['flowEnd']) */
+    triggers?: ('flowEnd' | 'agentDisconnect' | 'custom')[];
+    /** Called when user submits a rating */
+    onRate?: (rating: number, feedback?: string) => void;
+    /** Endpoint to POST rating data */
+    endpoint?: string;
+    /** Custom headers for the POST */
+    headers?: Record<string, string>;
+}): ChatPlugin;
+
 /**
  * Reminder Plugin — sends reminder messages to users after configured delays
  */
@@ -1199,6 +1670,13 @@ export declare function reminderPlugin(options?: {
 
 export declare const RemoveIcon: default_2.FC<IconProps>;
 
+/**
+ * Lightweight markdown-to-JSX renderer. No external dependencies.
+ * Supports: bold, italic, code (inline + block), links, lists,
+ * strikethrough, headings, and line breaks.
+ */
+export declare function renderMarkdown(text: string, options?: MarkdownOptions): default_2.ReactNode;
+
 /** Resolved event names with defaults applied */
 export declare interface ResolvedLiveAgentEvents {
     agentMessage: string;
@@ -1225,6 +1703,13 @@ declare interface ScheduledMessage {
     interval?: number;
 }
 
+declare interface ScheduledMessage_2 {
+    id: string;
+    text: string;
+    scheduledAt: number;
+    sender?: 'bot' | 'user';
+}
+
 /**
  * Scheduler Plugin — triggers bot messages at scheduled times or intervals
  */
@@ -1272,6 +1757,21 @@ export declare interface StepComponentProps {
     onComplete: (result?: FlowActionResult) => void;
 }
 
+export declare function summaryPlugin(options?: SummaryPluginOptions): ChatPlugin;
+
+declare interface SummaryPluginOptions {
+    /** AI endpoint for summarization (POST with { messages } body) */
+    endpoint?: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Fallback: extract key points from messages locally (default: true) */
+    localFallback?: boolean;
+    /** Max messages to include in summary request (default: 50) */
+    maxMessages?: number;
+    /** Callback with generated summary */
+    onSummary?: (summary: string) => void;
+}
+
 /**
  * Sync Plugin — syncs chat data with a backend endpoint
  */
@@ -1282,6 +1782,21 @@ export declare function syncPlugin(options: {
     sessionKey?: string;
 }): ChatPlugin;
 
+/**
+ * Tags Plugin — allows tagging conversations by topic for multi-flow bots.
+ * Tags are stored in metadata and can be used for routing/analytics.
+ */
+export declare function tagsPlugin(options?: {
+    /** Predefined tags users can assign */
+    availableTags?: string[];
+    /** Storage key for persisting tags */
+    storageKey?: string;
+    /** Called when a tag is added */
+    onTagAdded?: (tag: string, messageId?: string) => void;
+    /** Called when a tag is removed */
+    onTagRemoved?: (tag: string) => void;
+}): ChatPlugin;
+
 export declare const TextField: default_2.FC<TextFieldProps>;
 
 declare interface TextFieldProps {
@@ -1310,6 +1825,43 @@ export declare function themePlugin(options?: {
     cssVariable?: string;
 }): ChatPlugin;
 
+export declare function themeTogglePlugin(options?: ThemeTogglePluginOptions): ChatPlugin;
+
+declare interface ThemeTogglePluginOptions {
+    /** Default mode (default: 'light') */
+    defaultMode?: 'light' | 'dark';
+    /** Persist preference in localStorage */
+    persist?: boolean;
+    /** Storage key */
+    storageKey?: string;
+    /** Callback on toggle */
+    onToggle?: (mode: 'light' | 'dark') => void;
+}
+
+declare interface TimeSlot {
+    id: string;
+    date: string;
+    time: string;
+    available: boolean;
+}
+
+export declare function transcriptExportPlugin(options?: TranscriptExportPluginOptions): ChatPlugin;
+
+declare interface TranscriptExportPluginOptions {
+    /** Export format (default: 'text') */
+    format?: TranscriptFormat;
+    /** Filename prefix (default: 'chat-transcript') */
+    filename?: string;
+    /** Include timestamps (default: true) */
+    includeTimestamps?: boolean;
+    /** Callback with exported content */
+    onExport?: (content: string, format: TranscriptFormat) => void;
+    /** Custom header text in exported file */
+    header?: string;
+}
+
+declare type TranscriptFormat = 'text' | 'json' | 'csv' | 'html';
+
 /**
  * Transfer Plugin — transfers chat to different departments/agents via API
  */
@@ -1322,6 +1874,27 @@ export declare function transferPlugin(options: {
     transferMessage?: string;
 }): ChatPlugin;
 
+export declare function translationPlugin(options: TranslationPluginOptions): ChatPlugin;
+
+declare interface TranslationPluginOptions {
+    /** Translation API endpoint (POST with { text, from, to } body) */
+    endpoint: string;
+    /** Request headers (e.g., API key) */
+    headers?: Record<string, string>;
+    /** Source language (default: 'auto') */
+    sourceLang?: string;
+    /** Target language (default: 'en') */
+    targetLang?: string;
+    /** Translate bot messages for user (default: true) */
+    translateIncoming?: boolean;
+    /** Translate user messages for bot/agent (default: false) */
+    translateOutgoing?: boolean;
+    /** Show original text alongside translation (default: false) */
+    showOriginal?: boolean;
+    /** Callback with translation result */
+    onTranslate?: (original: string, translated: string, lang: string) => void;
+}
+
 declare type Translations = Record<string, Record<string, string>>;
 
 declare type TriggerType = 'exitIntent' | 'idle' | 'scroll' | 'pageLoad' | 'custom';
@@ -1449,4 +2022,17 @@ export declare interface WelcomeScreenSlotProps {
     component?: ReactNode;
 }
 
+export declare function whisperPlugin(options?: WhisperPluginOptions): ChatPlugin;
+
+declare interface WhisperPluginOptions {
+    /** Role that can see whispers (default: 'agent') */
+    visibleTo?: string;
+    /** Current viewer role — set to 'agent' for agents, 'user' for end-users */
+    viewerRole?: 'agent' | 'supervisor' | 'user';
+    /** Callback when whisper is sent */
+    onWhisper?: (message: ChatMessage) => void;
+    /** Webhook to forward whispers to */
+    webhookUrl?: string;
+}
+
 export { }