@ringg/core 0.0.1-alpha.10

package/dist/index.d.cts

@@ -0,0 +1,762 @@
+/**
+ * Theme types for the widget.
+ * Covers both widget-level theming and per-component theming.
+ */
+type ButtonStyle = "rounded" | "pill" | "square";
+type ButtonSize = "sm" | "md" | "lg";
+/**
+ * Widget-level theme — applies to the entire widget chrome
+ * (header, messages, buttons, trigger FAB, etc.)
+ */
+interface WidgetTheme {
+    /** Main accent color (buttons, selected states). Supports CSS gradients. */
+    primaryColor?: string;
+    /** Text color on primary-colored elements */
+    primaryTextColor?: string;
+    /** Widget background */
+    backgroundColor?: string;
+    /** Cards, inputs background */
+    surfaceColor?: string;
+    /** Main text color */
+    textColor?: string;
+    /** Secondary/muted text color */
+    mutedTextColor?: string;
+    /** Border color */
+    borderColor?: string;
+    /** Error state color */
+    errorColor?: string;
+    /** Success state color */
+    successColor?: string;
+    /** Button corner style */
+    buttonStyle?: ButtonStyle;
+    /** Global border radius (e.g., "12px", "20px") */
+    borderRadius?: string;
+    /** Font family */
+    fontFamily?: string;
+}
+/**
+ * Component-level theme — applies to interactive components
+ * (calendar, form, buttons, confirmation).
+ * Extends widget theme with additional component-specific properties.
+ */
+interface ComponentTheme {
+    primaryColor?: string;
+    primaryTextColor?: string;
+    backgroundColor?: string;
+    surfaceColor?: string;
+    textColor?: string;
+    mutedTextColor?: string;
+    borderColor?: string;
+    errorColor?: string;
+    successColor?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    borderRadius?: string;
+    padding?: string;
+    buttonStyle?: ButtonStyle;
+    buttonSize?: ButtonSize;
+}
+/** Fully resolved widget theme — all fields guaranteed present */
+type ResolvedWidgetTheme = Required<WidgetTheme>;
+
+/**
+ * Slash command types — commands available during text chat.
+ */
+type SlashCommandToolType = "CALLBACK_SCHEDULE_TOOL" | "WIDGET_TOOL" | "DISEASE_ACCEPTANCE_TOOL";
+interface SlashCommand {
+    tool_type: SlashCommandToolType;
+    command: string;
+    display_name: string;
+    description: string;
+}
+
+/**
+ * Widget configuration types.
+ * These define the public API surface for consumers initializing the widget.
+ */
+
+type MediaType = "audio" | "text";
+type EnvironmentMode = "dev" | "stage" | "prod";
+type TriggerPlacement = "fixed" | "absolute";
+type TriggerAlignment = "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+type WidgetAlignment = "bottom-right" | "bottom-center" | "bottom-left";
+interface WidgetPositionConfig {
+    triggerPlacement?: TriggerPlacement;
+    triggerAlignment?: TriggerAlignment;
+    hideTriggerOnExpand?: boolean;
+    widgetAlignment?: WidgetAlignment;
+}
+interface LegalDisclaimerConfig {
+    text: string;
+    links?: Record<string, string>;
+}
+/** Styles that are safe to pass cross-platform (subset of CSS properties that map to RN) */
+interface PortableStyles {
+    height?: string | number;
+    width?: string | number;
+    backgroundColor?: string;
+    padding?: string | number;
+    borderRadius?: string | number;
+}
+interface ButtonIconConfig {
+    size?: string | number;
+    url?: string;
+}
+interface ButtonsConfig {
+    mic?: {
+        styles?: PortableStyles;
+    };
+    modalTrigger?: {
+        styles?: PortableStyles;
+        icon?: ButtonIconConfig;
+    };
+    text?: {
+        textBeforeCall?: string;
+        textDuringCall?: string;
+        styles?: PortableStyles;
+    };
+    call?: {
+        textBeforeCall?: string;
+        textDuringCall?: string;
+        styles?: PortableStyles;
+    };
+}
+interface FeedbackScreenConfig {
+    title?: string;
+    description?: string;
+    starsCount?: number;
+    starsStyles?: {
+        filledColor?: string;
+        emptyColor?: string;
+    };
+    placeholder?: string;
+    submitBtnCTA?: string;
+    submitBtnStyles?: PortableStyles;
+}
+interface InnerWindowConfig {
+    width?: string | number;
+    height?: string | number;
+    borderRadius?: string | number;
+}
+/**
+ * The main configuration object consumers pass to initialize the widget.
+ * Used by both web (loadAgent) and React Native (<RinggWidget />) entry points.
+ */
+interface RinggWidgetConfig {
+    /** Agent identifier — required */
+    agentId: string;
+    /** API key for authentication — required */
+    xApiKey: string;
+    /** Custom variables passed to the agent (e.g., user name, role) */
+    variables: Record<string, string>;
+    /** Environment mode — determines backend/LiveKit URLs */
+    mode?: EnvironmentMode;
+    /** Widget title displayed in the header */
+    title?: string;
+    /** Widget description displayed in the header */
+    description?: string;
+    /** Default communication tab */
+    defaultTab?: MediaType;
+    /** Whether to hide the audio/text tab selector */
+    hideTabSelector?: boolean;
+    /** Custom logo URL for the widget header */
+    logoUrl?: string;
+    /** Styles for the logo element */
+    logoStyles?: PortableStyles;
+    /** Slash commands available from config (merged with runtime ones) */
+    enabledSlashCommands?: SlashCommand[];
+    /** App-wide theming */
+    theme?: WidgetTheme;
+    /** Widget positioning (web-only, ignored on RN) */
+    widgetPosition?: WidgetPositionConfig;
+    /** Legal disclaimer shown before call start */
+    legalDisclaimer?: LegalDisclaimerConfig;
+    /** Button customizations */
+    buttons?: ButtonsConfig;
+    /** Post-call feedback screen customizations */
+    feedbackScreen?: FeedbackScreenConfig;
+    /** Widget window dimensions (web-only) */
+    innerWindowProps?: InnerWindowConfig;
+    /** URL for the notification sound */
+    notificationTuneUrl?: string;
+}
+/** Default values for optional config fields */
+declare const DEFAULT_CONFIG: {
+    readonly mode: "prod";
+    readonly title: "Ringg AI Support";
+    readonly description: "Ringg AI offers 24/7 voice support to handle your business calls efficiently and professionally";
+    readonly defaultTab: MediaType;
+    readonly hideTabSelector: false;
+    readonly notificationTuneUrl: "https://assets.ringg.ai/audios/misc/widget_notification.mp3";
+};
+
+/**
+ * Interactive component types pushed from the backend during a call.
+ * These define the data contracts for calendar, form, buttons, confirmation, and flows.
+ */
+
+interface BaseComponent {
+    component_type: string;
+    component_id: string;
+    data: unknown;
+    theme?: ComponentTheme;
+}
+interface CalendarSlot {
+    id: string;
+    datetime: string;
+}
+interface CalendarBookingData {
+    available_slots: CalendarSlot[];
+    timezone: string;
+    title: string;
+}
+interface CalendarBookingPayload extends BaseComponent {
+    component_type: "calendar_booking";
+    data: CalendarBookingData;
+}
+type FormFieldType = "text" | "email" | "tel" | "number" | "select" | "multiselect" | "textarea" | "date" | "boolean";
+interface FormFieldOption {
+    value: string;
+    label: string;
+}
+interface FormField {
+    name: string;
+    type: FormFieldType;
+    label: string;
+    placeholder?: string;
+    required?: boolean;
+    options?: string[] | FormFieldOption[];
+    validation?: {
+        pattern?: string;
+        minLength?: number;
+        maxLength?: number;
+        message?: string;
+    };
+}
+interface FormData {
+    title: string;
+    description?: string;
+    fields: FormField[];
+    submit_label?: string;
+}
+interface FormPayload extends BaseComponent {
+    component_type: "form";
+    data: FormData;
+}
+interface ButtonAction {
+    type: "navigate" | "trigger_component" | "api_call";
+    url?: string;
+    component_type?: string;
+    method?: "POST" | "GET";
+    endpoint?: string;
+    payload?: Record<string, string>;
+}
+interface ButtonItem {
+    id: string;
+    label: string;
+    style?: "primary" | "secondary" | "outline" | "destructive";
+    action: ButtonAction;
+}
+interface ButtonsData {
+    title?: string;
+    buttons: ButtonItem[];
+}
+interface ButtonsPayload extends BaseComponent {
+    component_type: "buttons";
+    data: ButtonsData;
+}
+interface ConfirmationData {
+    title: string;
+    message: string;
+    icon?: "success" | "info" | "warning" | "error";
+    details?: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+interface ConfirmationPayload extends BaseComponent {
+    component_type: "confirmation";
+    data: ConfirmationData;
+}
+interface FlowStep {
+    id: string;
+    title: string;
+    component: SimpleComponentPayload;
+}
+interface InteractiveFlowData {
+    title?: string;
+    steps: FlowStep[];
+    on_complete: {
+        method: "POST" | "GET";
+        endpoint: string;
+        payload: Record<string, string>;
+    };
+}
+interface InteractiveFlowPayload extends BaseComponent {
+    component_type: "interactive_flow";
+    data: InteractiveFlowData;
+}
+type ComponentPayload = CalendarBookingPayload | FormPayload | ButtonsPayload | ConfirmationPayload | InteractiveFlowPayload;
+type SimpleComponentPayload = CalendarBookingPayload | FormPayload | ButtonsPayload | ConfirmationPayload;
+interface ComponentActionResponse {
+    success: boolean;
+    message: string;
+    next_step?: SimpleComponentPayload;
+    confirmation?: ConfirmationData;
+}
+interface GroupedSlots {
+    date: string;
+    dateLabel: string;
+    slots: CalendarSlot[];
+}
+
+/**
+ * Widget event types — dispatched to the host application.
+ * These provide lifecycle hooks for the embedding app to react to widget state changes.
+ */
+
+type WidgetEventName = "ringg:widget_status" | "ringg:conversation_status" | "ringg:feedback_status" | "ringg:calendar_booking" | "ringg:component_acknowledgement";
+interface WidgetStatusPayload {
+    status: "maximised" | "minimised";
+    mode: MediaType;
+}
+interface ConversationStatusPayload {
+    status: "started" | "ended";
+    mode: MediaType;
+    callId: string;
+}
+interface FeedbackStatusPayload {
+    status: "submitted" | "skipped";
+    callId: string;
+    rating?: number;
+}
+interface CalendarBookingEventPayload {
+    status: "shown" | "confirmed" | "failed";
+    componentId: string;
+    slotId?: string;
+    message?: string;
+}
+interface ComponentAcknowledgementPayload {
+    componentName: string;
+    componentId: string;
+    status: string;
+}
+/** Union of all possible event payloads */
+type WidgetEventPayload = WidgetStatusPayload | ConversationStatusPayload | FeedbackStatusPayload | CalendarBookingEventPayload | ComponentAcknowledgementPayload;
+/**
+ * Event map — maps event names to their payload types.
+ * Enables type-safe event dispatch/subscription.
+ */
+interface WidgetEventMap {
+    "ringg:widget_status": WidgetStatusPayload;
+    "ringg:conversation_status": ConversationStatusPayload;
+    "ringg:feedback_status": FeedbackStatusPayload;
+    "ringg:calendar_booking": CalendarBookingEventPayload;
+    "ringg:component_acknowledgement": ComponentAcknowledgementPayload;
+}
+
+/**
+ * Domain-specific widget types (e.g., disease/policy finder).
+ */
+type SubQuestionType = "SINGLE_SELECT" | "MULTI_SELECT" | "INPUT";
+interface SubQuestion {
+    question_id: string;
+    question_type: SubQuestionType;
+    label: string;
+    options?: string[];
+    placeholder?: string;
+}
+interface DiseaseOption {
+    disease_name: string;
+    sub_questions: SubQuestion[];
+}
+interface SubQuestionResponse {
+    question_id: string;
+    answer: string;
+}
+interface DiseaseResponse {
+    disease_name: string;
+    sub_questions: SubQuestionResponse[];
+}
+interface WidgetSubmitPayload {
+    selections: DiseaseResponse[];
+}
+
+/**
+ * Chat message types — the normalized message format used across platforms.
+ */
+
+interface ChatMessage {
+    name: string;
+    message: string;
+    isSelf: boolean;
+    timestamp: number;
+    sourceUrl?: string;
+    /** When present, this message renders a component instead of text */
+    componentType?: string;
+    componentData?: ComponentPayload;
+}
+
+/**
+ * LiveKit adapter interface — platform implementations inject the actual SDK.
+ *
+ * Web: uses `livekit-client` + `@livekit/components-react`
+ * React Native: uses `@livekit/react-native`
+ *
+ * The core never imports any LiveKit SDK directly.
+ */
+interface RpcInvocation {
+    /** The RPC method name */
+    method: string;
+    /** The JSON-encoded payload */
+    payload: string;
+    /** Identity of the caller */
+    callerIdentity: string;
+}
+interface TextStreamInfo {
+    /** Full text content of the stream */
+    message: string;
+    /** Identity of the participant who sent the stream */
+    participantIdentity: string;
+}
+interface TranscriptionSegment {
+    id: string;
+    text: string;
+    isFinal: boolean;
+    participantIdentity: string;
+    isAgent: boolean;
+}
+type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
+/**
+ * Abstract LiveKit operations for cross-platform use.
+ * Each platform provides its own implementation.
+ */
+interface LiveKitAdapter {
+    /** Current connection state */
+    getConnectionState(): ConnectionState;
+    /** Connect to a LiveKit room */
+    connect(url: string, token: string): Promise<void>;
+    /** Disconnect from the current room */
+    disconnect(): void;
+    /** Enable or disable the local microphone */
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    /** Check if microphone is currently enabled */
+    isMicrophoneEnabled(): boolean;
+    /** Register an RPC method handler */
+    registerRpcMethod(method: string, handler: (data: RpcInvocation) => Promise<string>): void;
+    /** Unregister an RPC method handler */
+    unregisterRpcMethod(method: string): void;
+    /** Perform an RPC call to a remote participant */
+    performRpc(destinationIdentity: string, method: string, payload: string): Promise<string>;
+    /** Register a text stream handler */
+    registerTextStreamHandler(topic: string, handler: (info: TextStreamInfo) => void): void;
+    /** Unregister a text stream handler */
+    unregisterTextStreamHandler(topic: string): void;
+    /** Subscribe to connection state changes */
+    onConnectionStateChange(handler: (state: ConnectionState) => void): () => void;
+    /** Subscribe to participant disconnect events */
+    onParticipantDisconnected(handler: (identity: string) => void): () => void;
+    /** Subscribe to room disconnect events */
+    onDisconnected(handler: () => void): () => void;
+    /** Subscribe to transcription segments (audio mode) */
+    onTranscription(handler: (segment: TranscriptionSegment) => void): () => void;
+    /** Get the identity of the agent participant (if connected) */
+    getAgentIdentity(): string | null;
+    /** Get the local participant identity */
+    getLocalIdentity(): string;
+    /** Dispose all listeners and clean up */
+    dispose(): void;
+}
+
+/**
+ * Event bus interface — abstraction over platform-specific event dispatch.
+ *
+ * Web: uses `window.dispatchEvent(new CustomEvent(...))` / `window.addEventListener`
+ * React Native: uses callback props or an EventEmitter
+ *
+ * This enables the host application to listen to widget lifecycle events
+ * without coupling to a specific event mechanism.
+ */
+
+interface EventBus {
+    /**
+     * Emit a typed event to the host application.
+     */
+    emit<K extends WidgetEventName>(event: K, payload: WidgetEventMap[K]): void;
+    /**
+     * Subscribe to a typed event. Returns an unsubscribe function.
+     */
+    on<K extends WidgetEventName>(event: K, handler: (payload: WidgetEventMap[K]) => void): () => void;
+    /**
+     * Remove all listeners for a specific event, or all events if no name is provided.
+     */
+    off(event?: WidgetEventName): void;
+}
+/**
+ * Web implementation — dispatches/listens via DOM CustomEvents on `window`.
+ * This is the default for web-based widget usage.
+ */
+declare class DomEventBus implements EventBus {
+    private listeners;
+    emit<K extends WidgetEventName>(event: K, payload: WidgetEventMap[K]): void;
+    on<K extends WidgetEventName>(event: K, handler: (payload: WidgetEventMap[K]) => void): () => void;
+    off(event?: WidgetEventName): void;
+}
+/**
+ * In-memory event bus — for React Native or testing.
+ * Events are dispatched to registered JS callbacks, not DOM events.
+ */
+declare class CallbackEventBus implements EventBus {
+    private listeners;
+    emit<K extends WidgetEventName>(event: K, payload: WidgetEventMap[K]): void;
+    on<K extends WidgetEventName>(event: K, handler: (payload: WidgetEventMap[K]) => void): () => void;
+    off(event?: WidgetEventName): void;
+}
+
+/**
+ * API client for the Ringg backend.
+ * Pure fetch-based — works in any JS runtime (browser, Node, React Native).
+ */
+
+interface EnvironmentUrls {
+    backendUrl: string;
+    livekitUrl: string;
+}
+/**
+ * Resolve backend and LiveKit URLs for a given environment mode.
+ * Consumers must provide these URLs — the core doesn't embed them.
+ */
+interface UrlResolver {
+    resolve(mode: EnvironmentMode): EnvironmentUrls;
+}
+/**
+ * Static URL resolver — URLs are provided directly.
+ */
+declare class StaticUrlResolver implements UrlResolver {
+    private urls;
+    constructor(urls: Record<EnvironmentMode, EnvironmentUrls>);
+    resolve(mode: EnvironmentMode): EnvironmentUrls;
+}
+interface WebcallResponse {
+    call_id: string;
+    user_token: string;
+    enabled_slash_commands?: SlashCommand[];
+}
+interface FeedbackPayload {
+    rating: number;
+    comment: string;
+}
+interface ApiClientConfig {
+    urlResolver: UrlResolver;
+    mode: EnvironmentMode;
+    xApiKey: string;
+}
+declare class RinggApiClient {
+    private backendUrl;
+    private xApiKey;
+    constructor(config: ApiClientConfig);
+    /** Common headers for all API requests. Includes Origin for CORS. */
+    private get headers();
+    /**
+     * Initiate a webcall — returns the LiveKit token and call ID.
+     */
+    startWebcall(params: {
+        agentId: string;
+        variables: Record<string, string>;
+        mediaType: "audio" | "text";
+    }): Promise<WebcallResponse>;
+    /**
+     * Submit post-call feedback.
+     */
+    submitFeedback(callId: string, feedback: FeedbackPayload): Promise<void>;
+    /**
+     * Call a component API endpoint (for interactive flows).
+     */
+    callComponentApi(method: "POST" | "GET", endpoint: string, payload: Record<string, string>): Promise<ComponentActionResponse>;
+}
+
+/**
+ * Widget state machine — framework-agnostic state management.
+ *
+ * This is the pure logic layer for widget open/close/feedback lifecycle.
+ * Framework-specific wrappers (React hooks, RN state) wrap this controller.
+ *
+ * The controller emits events via the EventBus so the host app can react.
+ */
+
+type WidgetViewState = "closed" | "open" | "feedback";
+interface WidgetStateSnapshot {
+    viewState: WidgetViewState;
+    currentCallId: string | null;
+    callMode: MediaType;
+}
+type WidgetStateListener = (snapshot: WidgetStateSnapshot) => void;
+declare class WidgetStateController {
+    private eventBus;
+    private viewState;
+    private currentCallId;
+    private callMode;
+    private listeners;
+    private conversationEndDispatched;
+    constructor(eventBus: EventBus, initialCallMode?: MediaType);
+    getSnapshot(): WidgetStateSnapshot;
+    get isOpen(): boolean;
+    get isShowingFeedback(): boolean;
+    open(): void;
+    minimize(): void;
+    close(): void;
+    toggle(): void;
+    showFeedback(): void;
+    setCallMode(mode: MediaType): void;
+    setCurrentCallId(callId: string): void;
+    dispatchConversationStart(mode: MediaType, callId: string): void;
+    dispatchConversationEnd(mode: MediaType, callId: string): void;
+    subscribe(listener: WidgetStateListener): () => void;
+    private notify;
+    dispose(): void;
+}
+
+/**
+ * Theme engine — resolves, merges, and provides theme values.
+ * Pure functions with no framework dependency.
+ */
+
+declare const DEFAULT_WIDGET_THEME: ResolvedWidgetTheme;
+/** Merge a partial user theme with the defaults. Returns a fully resolved theme. */
+declare function mergeWidgetTheme(theme?: WidgetTheme): ResolvedWidgetTheme;
+/** Merge a component-level theme with the widget theme as fallback. */
+declare function mergeComponentTheme(componentTheme?: ComponentTheme, widgetTheme?: ResolvedWidgetTheme): ComponentTheme;
+/** Get button border radius based on style */
+declare function getButtonRadius(style?: ButtonStyle): string;
+/** Check if a color is considered "light" (for auto-contrast) */
+declare function isLightColor(hexColor: string): boolean;
+/** Get a contrasting text color (black or white) for a given background */
+declare function getContrastingTextColor(bgColor: string): string;
+declare const WIDGET_PRESET_THEMES: Record<string, WidgetTheme>;
+
+/**
+ * Gradient-aware style utilities for the widget theme system.
+ *
+ * CSS `backgroundColor` does not support gradient values — only the `background`
+ * shorthand does. These helpers detect whether a color value is a solid hex/rgb
+ * or a CSS gradient string, then return the correct CSS property.
+ *
+ * These utilities are platform-agnostic (no DOM dependency).
+ * Platform renderers consume the output to apply styles appropriately.
+ */
+/** Detect whether a CSS color value is a gradient string. */
+declare function isGradient(color: string): boolean;
+/** Extract all hex and rgb/rgba color values from a gradient string. */
+declare function extractColorsFromGradient(gradient: string): string[];
+/**
+ * Return the dominant (first) color from a gradient, or the color as-is for solid values.
+ * Falls back to the original string if no colors can be extracted.
+ */
+declare function getDominantColor(color: string): string;
+/**
+ * Determine the correct CSS properties for a background color.
+ *
+ * Returns `{ backgroundColor }` for solid colors, `{ background }` for gradients.
+ *
+ * On web, spread this directly into a style object.
+ * On React Native, gradients aren't natively supported — use `getDominantColor()`
+ * to fall back to a solid color.
+ */
+declare function colorToBackground(color: string): {
+    backgroundColor?: string;
+    background?: string;
+};
+/**
+ * Always return a solid hex/rgb color string.
+ * Extracts the dominant color from gradients, or returns the color as-is.
+ * Use for properties that don't support gradients: border, box-shadow, accent-color.
+ */
+declare function colorToSolid(color: string): string;
+/**
+ * Return the correct CSS properties for a border color.
+ * Solid colors -> `{ borderColor }`, Gradients -> `{ borderImage, borderStyle: "solid" }`.
+ */
+declare function colorToBorder(color: string): Record<string, string>;
+
+/**
+ * Component data helpers — pure functions for working with interactive component data.
+ * Shared across web and React Native.
+ */
+
+/** Group calendar slots by date for display */
+declare function groupSlotsByDate(slots: CalendarSlot[]): GroupedSlots[];
+/** Format a slot time for display */
+declare function formatSlotTime(datetime: string, timezone?: string): string;
+/** Format a slot date for display */
+declare function formatSlotDate(datetime: string, timezone?: string): string;
+/** Replace placeholders in a payload template with actual values */
+declare function buildPayload(template: Record<string, string>, values: Record<string, string>): Record<string, string>;
+declare function isCalendarBooking(payload: ComponentPayload): payload is CalendarBookingPayload;
+declare function isForm(payload: ComponentPayload): payload is FormPayload;
+declare function isButtons(payload: ComponentPayload): payload is ButtonsPayload;
+declare function isConfirmation(payload: ComponentPayload): payload is ConfirmationPayload;
+declare function isInteractiveFlow(payload: ComponentPayload): payload is InteractiveFlowPayload;
+
+/** Filter slash commands by query (must start with "/") */
+declare function filterSlashCommands(commands: SlashCommand[], query: string): SlashCommand[];
+
+declare function hasSubQuestions(disease: DiseaseOption): boolean;
+declare function getDiseasesWithSubQuestions(selected: DiseaseOption[]): DiseaseOption[];
+declare function formatTimestamp(dateString: string | number, mode?: "fromnow" | "formatted"): string;
+/** Detect if a participant identity is an agent */
+declare function isAgentIdentity(identity: string): boolean;
+
+/**
+ * RPC message formatting — transforms between backend RPC format and internal component format.
+ *
+ * The backend sends `send_dynamic_data` RPCs with a format like:
+ *   { component_type: "render_component_calendar", component_config: { ... } }
+ *
+ * The widget needs them in an internal format like:
+ *   { component_type: "calendar_booking", component_id: "calendar_1234", data: { ... } }
+ *
+ * This module handles both directions of transformation.
+ */
+
+/**
+ * Transform a backend RPC payload into the internal component format.
+ * Returns null if the component type is unknown.
+ */
+declare function transformRpcToComponent(componentName: string, rpcPayload: Record<string, unknown>): SimpleComponentPayload | InteractiveFlowPayload | null;
+/**
+ * Format a component response payload for sending back to the backend via RPC.
+ * Used when the user interacts with a component (e.g., selects a calendar slot, submits a form).
+ */
+declare function formatComponentResponse(componentName: string, componentId: string, responseData: Record<string, unknown>, originalConfig: unknown): {
+    method: string;
+    payload: string;
+};
+/**
+ * Format a disease widget submission for sending via RPC.
+ */
+declare function formatDiseaseSubmission(componentId: string, selections: Array<{
+    disease_name: string;
+    sub_questions: Array<{
+        question_id: string;
+        answer: string;
+    }>;
+}>): {
+    method: string;
+    payload: string;
+};
+/**
+ * Format a disease search query for sending via RPC.
+ */
+declare function formatDiseaseSearch(query: string): {
+    method: string;
+    payload: string;
+};
+/**
+ * Format a slash command for sending via RPC.
+ */
+declare function formatSlashCommand(command: string): {
+    method: string;
+    payload: string;
+};
+
+export { type ApiClientConfig, type BaseComponent, type ButtonAction, type ButtonIconConfig, type ButtonItem, type ButtonSize, type ButtonStyle, type ButtonsConfig, type ButtonsData, type ButtonsPayload, type CalendarBookingData, type CalendarBookingEventPayload, type CalendarBookingPayload, type CalendarSlot, CallbackEventBus, type ChatMessage, type ComponentAcknowledgementPayload, type ComponentActionResponse, type ComponentPayload, type ComponentTheme, type ConfirmationData, type ConfirmationPayload, type ConnectionState, type ConversationStatusPayload, DEFAULT_CONFIG, DEFAULT_WIDGET_THEME, type DiseaseOption, type DiseaseResponse, DomEventBus, type EnvironmentMode, type EnvironmentUrls, type EventBus, type FeedbackPayload, type FeedbackScreenConfig, type FeedbackStatusPayload, type FlowStep, type FormData, type FormField, type FormFieldOption, type FormFieldType, type FormPayload, type GroupedSlots, type InnerWindowConfig, type InteractiveFlowData, type InteractiveFlowPayload, type LegalDisclaimerConfig, type LiveKitAdapter, type MediaType, type PortableStyles, type ResolvedWidgetTheme, RinggApiClient, type RinggWidgetConfig, type RpcInvocation, type SimpleComponentPayload, type SlashCommand, type SlashCommandToolType, StaticUrlResolver, type SubQuestion, type SubQuestionResponse, type SubQuestionType, type TextStreamInfo, type TranscriptionSegment, type TriggerAlignment, type TriggerPlacement, type UrlResolver, WIDGET_PRESET_THEMES, type WebcallResponse, type WidgetAlignment, type WidgetEventMap, type WidgetEventName, type WidgetEventPayload, type WidgetPositionConfig, WidgetStateController, type WidgetStateListener, type WidgetStateSnapshot, type WidgetStatusPayload, type WidgetSubmitPayload, type WidgetTheme, type WidgetViewState, buildPayload, colorToBackground, colorToBorder, colorToSolid, extractColorsFromGradient, filterSlashCommands, formatComponentResponse, formatDiseaseSearch, formatDiseaseSubmission, formatSlashCommand, formatSlotDate, formatSlotTime, formatTimestamp, getButtonRadius, getContrastingTextColor, getDiseasesWithSubQuestions, getDominantColor, groupSlotsByDate, hasSubQuestions, isAgentIdentity, isButtons, isCalendarBooking, isConfirmation, isForm, isGradient, isInteractiveFlow, isLightColor, mergeComponentTheme, mergeWidgetTheme, transformRpcToComponent };