@ringg/core 0.0.1-alpha.10

package/dist/index.cjs

@@ -0,0 +1,757 @@
+'use strict';
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  mode: "prod",
+  title: "Ringg AI Support",
+  description: "Ringg AI offers 24/7 voice support to handle your business calls efficiently and professionally",
+  defaultTab: "audio",
+  hideTabSelector: false,
+  notificationTuneUrl: "https://assets.ringg.ai/audios/misc/widget_notification.mp3"
+};
+
+// src/adapters/event-bus.ts
+var DomEventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  emit(event, payload) {
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent(event, { detail: payload }));
+    }
+  }
+  on(event, handler) {
+    if (typeof window === "undefined") return () => {
+    };
+    const wrappedHandler = ((e) => handler(e.detail));
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(wrappedHandler);
+    window.addEventListener(event, wrappedHandler);
+    return () => {
+      window.removeEventListener(event, wrappedHandler);
+      this.listeners.get(event)?.delete(wrappedHandler);
+    };
+  }
+  off(event) {
+    if (event) {
+      this.listeners.get(event)?.forEach((handler) => {
+        window.removeEventListener(event, handler);
+      });
+      this.listeners.delete(event);
+    } else {
+      this.listeners.forEach((handlers, eventName) => {
+        handlers.forEach((handler) => {
+          window.removeEventListener(eventName, handler);
+        });
+      });
+      this.listeners.clear();
+    }
+  }
+};
+var CallbackEventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  emit(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => handler(payload));
+    }
+  }
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const typedHandler = handler;
+    this.listeners.get(event).add(typedHandler);
+    return () => {
+      this.listeners.get(event)?.delete(typedHandler);
+    };
+  }
+  off(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+};
+
+// src/api/client.ts
+var StaticUrlResolver = class {
+  constructor(urls) {
+    this.urls = urls;
+  }
+  resolve(mode) {
+    return this.urls[mode];
+  }
+};
+var RinggApiClient = class {
+  constructor(config) {
+    const { backendUrl } = config.urlResolver.resolve(config.mode);
+    this.backendUrl = backendUrl;
+    this.xApiKey = config.xApiKey;
+  }
+  /** Common headers for all API requests. Includes Origin for CORS. */
+  get headers() {
+    return {
+      "Content-Type": "application/json",
+      "X-API-KEY": this.xApiKey,
+      Origin: "http://localhost:3000"
+    };
+  }
+  /**
+   * Initiate a webcall — returns the LiveKit token and call ID.
+   */
+  async startWebcall(params) {
+    const response = await fetch(`${this.backendUrl}/calling/webcall`, {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: params.agentId,
+        custom_args_values: params.variables,
+        media_type: params.mediaType
+      }),
+      headers: this.headers
+    });
+    const responseText = await response.text();
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch {
+      throw new Error(responseText.slice(0, 200) || `Request failed with status ${response.status}`);
+    }
+    if (!response.ok) {
+      throw new Error(data?.message || "Failed to make call");
+    }
+    return {
+      call_id: data.call_id,
+      user_token: data.user_token,
+      enabled_slash_commands: data.enabled_slash_commands
+    };
+  }
+  /**
+   * Submit post-call feedback.
+   */
+  async submitFeedback(callId, feedback) {
+    await fetch(`${this.backendUrl}/calling/${callId}/feedback`, {
+      method: "POST",
+      body: JSON.stringify(feedback),
+      headers: this.headers
+    });
+  }
+  /**
+   * Call a component API endpoint (for interactive flows).
+   */
+  async callComponentApi(method, endpoint, payload) {
+    const url = endpoint.startsWith("http") ? endpoint : `${this.backendUrl}${endpoint}`;
+    const response = await fetch(url, {
+      method,
+      body: JSON.stringify(payload),
+      headers: this.headers
+    });
+    return response.json();
+  }
+};
+
+// src/state/widget-state.ts
+var WidgetStateController = class {
+  constructor(eventBus, initialCallMode = "audio") {
+    this.eventBus = eventBus;
+    this.viewState = "closed";
+    this.currentCallId = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.conversationEndDispatched = false;
+    this.callMode = initialCallMode;
+  }
+  // ─── Getters ─────────────────────────────────────────────────────────────
+  getSnapshot() {
+    return {
+      viewState: this.viewState,
+      currentCallId: this.currentCallId,
+      callMode: this.callMode
+    };
+  }
+  get isOpen() {
+    return this.viewState === "open" || this.viewState === "feedback";
+  }
+  get isShowingFeedback() {
+    return this.viewState === "feedback";
+  }
+  // ─── Mutations ───────────────────────────────────────────────────────────
+  open() {
+    if (this.viewState === "open") return;
+    this.viewState = "open";
+    this.eventBus.emit("ringg:widget_status", { status: "maximised", mode: this.callMode });
+    this.notify();
+  }
+  minimize() {
+    if (this.viewState === "closed") return;
+    this.viewState = "closed";
+    this.eventBus.emit("ringg:widget_status", { status: "minimised", mode: this.callMode });
+    this.notify();
+  }
+  close() {
+    this.viewState = "closed";
+    this.currentCallId = null;
+    this.eventBus.emit("ringg:widget_status", { status: "minimised", mode: this.callMode });
+    this.notify();
+  }
+  toggle() {
+    if (this.isOpen) {
+      this.minimize();
+    } else {
+      this.open();
+    }
+  }
+  showFeedback() {
+    this.viewState = "feedback";
+    this.notify();
+  }
+  setCallMode(mode) {
+    this.callMode = mode;
+    this.notify();
+  }
+  setCurrentCallId(callId) {
+    this.currentCallId = callId;
+    this.notify();
+  }
+  // ─── Conversation lifecycle helpers ──────────────────────────────────────
+  dispatchConversationStart(mode, callId) {
+    this.conversationEndDispatched = false;
+    this.eventBus.emit("ringg:conversation_status", { status: "started", mode, callId });
+  }
+  dispatchConversationEnd(mode, callId) {
+    if (!this.conversationEndDispatched) {
+      this.conversationEndDispatched = true;
+      this.eventBus.emit("ringg:conversation_status", { status: "ended", mode, callId });
+    }
+  }
+  // ─── Subscription ────────────────────────────────────────────────────────
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify() {
+    const snapshot = this.getSnapshot();
+    this.listeners.forEach((listener) => listener(snapshot));
+  }
+  // ─── Cleanup ─────────────────────────────────────────────────────────────
+  dispose() {
+    this.listeners.clear();
+  }
+};
+
+// src/theme/gradient-utils.ts
+var GRADIENT_REGEX = /^(linear-gradient|radial-gradient|conic-gradient|repeating-linear-gradient|repeating-radial-gradient|repeating-conic-gradient)\s*\(/i;
+var HEX_COLOR_REGEX = /#([0-9a-fA-F]{3,8})\b/g;
+var RGB_COLOR_REGEX = /rgba?\(\s*[\d.]+[\s,]+[\d.]+[\s,]+[\d.]+(?:[\s,/]+[\d.%]+)?\s*\)/g;
+function isGradient(color) {
+  return GRADIENT_REGEX.test(color.trim());
+}
+function extractColorsFromGradient(gradient) {
+  const colors = [];
+  const hexMatches = gradient.match(HEX_COLOR_REGEX);
+  if (hexMatches) colors.push(...hexMatches);
+  const rgbMatches = gradient.match(RGB_COLOR_REGEX);
+  if (rgbMatches) colors.push(...rgbMatches);
+  return colors;
+}
+function getDominantColor(color) {
+  if (!isGradient(color)) return color;
+  const colors = extractColorsFromGradient(color);
+  return colors.length > 0 ? colors[0] : color;
+}
+function colorToBackground(color) {
+  if (isGradient(color)) {
+    return { background: color };
+  }
+  return { backgroundColor: color };
+}
+function colorToSolid(color) {
+  return getDominantColor(color);
+}
+function colorToBorder(color) {
+  if (isGradient(color)) {
+    return {
+      borderImage: `${color} 1`,
+      borderStyle: "solid"
+    };
+  }
+  return { borderColor: color };
+}
+
+// src/theme/theme-engine.ts
+var DEFAULT_WIDGET_THEME = {
+  primaryColor: "#313335",
+  primaryTextColor: "#ffffff",
+  backgroundColor: "#fafafa",
+  surfaceColor: "#F3F3F5",
+  textColor: "#212121",
+  mutedTextColor: "#11111180",
+  borderColor: "#e5e5e5",
+  errorColor: "#ef4444",
+  successColor: "#10b981",
+  buttonStyle: "rounded",
+  borderRadius: "20px",
+  fontFamily: "inherit"
+};
+function mergeWidgetTheme(theme) {
+  return { ...DEFAULT_WIDGET_THEME, ...theme };
+}
+function mergeComponentTheme(componentTheme, widgetTheme) {
+  const base = widgetTheme ?? DEFAULT_WIDGET_THEME;
+  return {
+    primaryColor: base.primaryColor,
+    primaryTextColor: base.primaryTextColor,
+    backgroundColor: base.backgroundColor,
+    surfaceColor: base.surfaceColor,
+    textColor: base.textColor,
+    mutedTextColor: base.mutedTextColor,
+    borderColor: base.borderColor,
+    errorColor: base.errorColor,
+    successColor: base.successColor,
+    fontFamily: base.fontFamily,
+    borderRadius: base.borderRadius,
+    buttonStyle: base.buttonStyle,
+    ...componentTheme
+  };
+}
+function getButtonRadius(style) {
+  switch (style) {
+    case "pill":
+      return "9999px";
+    case "square":
+      return "6px";
+    case "rounded":
+    default:
+      return "12px";
+  }
+}
+function getLuminance(hexColor) {
+  const solid = getDominantColor(hexColor);
+  const hex = solid.replace("#", "");
+  const r = parseInt(hex.substr(0, 2), 16) / 255;
+  const g = parseInt(hex.substr(2, 2), 16) / 255;
+  const b = parseInt(hex.substr(4, 2), 16) / 255;
+  const toLinear = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function isLightColor(hexColor) {
+  try {
+    return getLuminance(hexColor) > 0.5;
+  } catch {
+    return true;
+  }
+}
+function getContrastingTextColor(bgColor) {
+  return isLightColor(bgColor) ? "#212121" : "#ffffff";
+}
+var WIDGET_PRESET_THEMES = {
+  light: {
+    primaryColor: "#18181b",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#ffffff",
+    surfaceColor: "#f4f4f5",
+    textColor: "#18181b",
+    mutedTextColor: "#71717a",
+    borderColor: "#e4e4e7"
+  },
+  warm: {
+    primaryColor: "#57534e",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#fefefe",
+    surfaceColor: "#fafaf9",
+    textColor: "#1c1917",
+    mutedTextColor: "#78716c",
+    borderColor: "#e7e5e4"
+  },
+  blue: {
+    primaryColor: "#2563eb",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#fafcff",
+    surfaceColor: "#f0f7ff",
+    textColor: "#1e3a8a",
+    mutedTextColor: "#64748b",
+    borderColor: "#dbeafe"
+  },
+  indigo: {
+    primaryColor: "#6366f1",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#fbfbff",
+    surfaceColor: "#f5f5ff",
+    textColor: "#312e81",
+    mutedTextColor: "#6b7280",
+    borderColor: "#e0e7ff"
+  },
+  green: {
+    primaryColor: "#16a34a",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#fbfefb",
+    surfaceColor: "#f0fdf4",
+    textColor: "#14532d",
+    mutedTextColor: "#6b7280",
+    borderColor: "#dcfce7"
+  },
+  orange: {
+    primaryColor: "#ea580c",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#fffdfb",
+    surfaceColor: "#fff7ed",
+    textColor: "#7c2d12",
+    mutedTextColor: "#78716c",
+    borderColor: "#ffedd5"
+  },
+  dark: {
+    primaryColor: "#fafafa",
+    primaryTextColor: "#18181b",
+    backgroundColor: "#18181b",
+    surfaceColor: "#27272a",
+    textColor: "#fafafa",
+    mutedTextColor: "#a1a1aa",
+    borderColor: "#3f3f46"
+  },
+  sunset: {
+    primaryColor: "linear-gradient(135deg, #f97316, #ef4444)",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#fffbf7",
+    surfaceColor: "#fff3e8",
+    textColor: "#7c2d12",
+    mutedTextColor: "#9a3412",
+    borderColor: "#fed7aa"
+  },
+  ocean: {
+    primaryColor: "linear-gradient(135deg, #667eea, #764ba2)",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#faf9ff",
+    surfaceColor: "#f0edff",
+    textColor: "#312e81",
+    mutedTextColor: "#6366f1",
+    borderColor: "#ddd6fe"
+  },
+  emerald: {
+    primaryColor: "linear-gradient(135deg, #10b981, #0ea5e9)",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#f7fdfb",
+    surfaceColor: "#ecfdf5",
+    textColor: "#064e3b",
+    mutedTextColor: "#047857",
+    borderColor: "#a7f3d0"
+  },
+  midnight: {
+    primaryColor: "linear-gradient(135deg, #6366f1, #8b5cf6)",
+    primaryTextColor: "#ffffff",
+    backgroundColor: "#18181b",
+    surfaceColor: "#27272a",
+    textColor: "#fafafa",
+    mutedTextColor: "#a1a1aa",
+    borderColor: "#3f3f46"
+  }
+};
+
+// src/helpers/component-helpers.ts
+function groupSlotsByDate(slots) {
+  const grouped = /* @__PURE__ */ new Map();
+  slots.forEach((slot) => {
+    const date = new Date(slot.datetime);
+    const dateKey = date.toISOString().split("T")[0];
+    if (!grouped.has(dateKey)) {
+      grouped.set(dateKey, []);
+    }
+    grouped.get(dateKey).push(slot);
+  });
+  return Array.from(grouped.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([dateKey, dateSlots]) => {
+    const date = new Date(dateKey);
+    return {
+      date: dateKey,
+      dateLabel: date.toLocaleDateString("en-US", {
+        weekday: "short",
+        month: "short",
+        day: "numeric"
+      }),
+      slots: dateSlots.sort((a, b) => new Date(a.datetime).getTime() - new Date(b.datetime).getTime())
+    };
+  });
+}
+function formatSlotTime(datetime, timezone) {
+  const date = new Date(datetime);
+  return date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: timezone
+  });
+}
+function formatSlotDate(datetime, timezone) {
+  const date = new Date(datetime);
+  return date.toLocaleDateString("en-US", {
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    timeZone: timezone
+  });
+}
+function buildPayload(template, values) {
+  const result = {};
+  for (const [key, value] of Object.entries(template)) {
+    if (typeof value === "string" && value.startsWith("{") && value.endsWith("}")) {
+      const placeholder = value.slice(1, -1);
+      result[key] = values[placeholder] ?? value;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isCalendarBooking(payload) {
+  return payload.component_type === "calendar_booking";
+}
+function isForm(payload) {
+  return payload.component_type === "form";
+}
+function isButtons(payload) {
+  return payload.component_type === "buttons";
+}
+function isConfirmation(payload) {
+  return payload.component_type === "confirmation";
+}
+function isInteractiveFlow(payload) {
+  return payload.component_type === "interactive_flow";
+}
+function filterSlashCommands(commands, query) {
+  if (!query.startsWith("/")) return [];
+  const search = query.slice(1).toLowerCase();
+  if (!search) return commands;
+  return commands.filter((cmd) => cmd.command.slice(1).toLowerCase().includes(search) || cmd.display_name.toLowerCase().includes(search));
+}
+function hasSubQuestions(disease) {
+  return disease.sub_questions.length > 0;
+}
+function getDiseasesWithSubQuestions(selected) {
+  return selected.filter(hasSubQuestions);
+}
+function formatTimestamp(dateString, mode = "fromnow") {
+  const date = new Date(dateString);
+  const now = /* @__PURE__ */ new Date();
+  if (mode === "fromnow") {
+    const diffSeconds = Math.floor((now.getTime() - date.getTime()) / 1e3);
+    if (diffSeconds < 60) return "Just now";
+    if (diffSeconds < 3600) {
+      const minutes = Math.floor(diffSeconds / 60);
+      return `${minutes} min ago`;
+    }
+    if (diffSeconds < 86400) {
+      const hours = Math.floor(diffSeconds / 3600);
+      return `${hours} hour${hours !== 1 ? "s" : ""} ago`;
+    }
+    const days = Math.floor(diffSeconds / 86400);
+    return `${days} day${days !== 1 ? "s" : ""} ago`;
+  }
+  return date.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true
+  });
+}
+function isAgentIdentity(identity) {
+  return identity.includes("agent") || identity.includes("Agent");
+}
+
+// src/rpc/rpc-formatter.ts
+function transformRpcToComponent(componentName, rpcPayload) {
+  const componentId = `${componentName}_${Date.now()}`;
+  const config = rpcPayload.component_config;
+  if (componentName === "calendar") {
+    return transformCalendar(componentId, config, rpcPayload);
+  }
+  if (componentName === "form") {
+    return transformForm(componentId, config);
+  }
+  if (componentName === "buttons") {
+    return transformButtons(componentId, config, rpcPayload);
+  }
+  if (componentName === "confirmation") {
+    return transformConfirmation(componentId, rpcPayload);
+  }
+  if (rpcPayload.component_type && rpcPayload.component_id) {
+    return rpcPayload;
+  }
+  return null;
+}
+function transformCalendar(componentId, config, rpcPayload) {
+  const configObj = config;
+  const slots = configObj?.slots || [];
+  const timezone = configObj?.timezone || "UTC";
+  return {
+    component_type: "calendar_booking",
+    component_id: componentId,
+    data: {
+      available_slots: slots.map((slot) => ({ id: slot.id, datetime: slot.datetime })),
+      timezone,
+      title: rpcPayload.title || "Select a time slot"
+    }
+  };
+}
+function transformForm(componentId, config) {
+  const configObj = config;
+  const transformedFields = (configObj?.fields || []).map((field) => ({
+    name: field.key || field.name || "",
+    type: mapFieldType(field.type),
+    label: field.description || field.label || field.key || field.name || "",
+    required: field.required,
+    placeholder: field.placeholder,
+    options: field.options
+  }));
+  return {
+    component_type: "form",
+    component_id: componentId,
+    data: {
+      title: configObj?.title || "Form",
+      description: configObj?.description,
+      fields: transformedFields,
+      submit_label: configObj?.cta || configObj?.submit_label || "Submit"
+    }
+  };
+}
+function transformButtons(componentId, config, rpcPayload) {
+  return {
+    component_type: "buttons",
+    component_id: componentId,
+    data: {
+      title: rpcPayload.title,
+      buttons: Array.isArray(config) ? config : []
+    }
+  };
+}
+function transformConfirmation(componentId, rpcPayload) {
+  return {
+    component_type: "confirmation",
+    component_id: componentId,
+    data: {
+      title: rpcPayload.title || "Confirmed",
+      message: rpcPayload.message || "",
+      icon: rpcPayload.icon || "success",
+      details: rpcPayload.details
+    }
+  };
+}
+function mapFieldType(backendType) {
+  const typeMap = {
+    text: "text",
+    string: "text",
+    number: "number",
+    email: "email",
+    phone_number: "tel",
+    single_select: "select",
+    multiselect: "multiselect",
+    checkbox: "boolean",
+    date: "date",
+    textarea: "textarea"
+  };
+  return typeMap[backendType] || "text";
+}
+function formatComponentResponse(componentName, componentId, responseData, originalConfig) {
+  const rpcMethod = "receive_dynamic_data";
+  let componentData;
+  if (componentName === "calendar") {
+    const slotId = responseData.step_data && responseData.step_data.slot_id;
+    const configObj = originalConfig;
+    const slots = configObj?.slots || [];
+    const timezone = configObj?.timezone || "UTC";
+    const selectedSlot = slots.find((slot) => slot.id === slotId);
+    componentData = {
+      id: selectedSlot?.id || slotId,
+      datetime: selectedSlot?.datetime || responseData.step_data?.slot_datetime,
+      timezone
+    };
+  } else if (componentName === "form") {
+    componentData = responseData.step_data || responseData.all_data;
+  } else if (componentName === "buttons") {
+    const buttonId = responseData.step_data && responseData.step_data.selected_button;
+    const buttons = Array.isArray(originalConfig) ? originalConfig : [];
+    const selectedButton = buttons.find((btn) => btn.id === buttonId);
+    componentData = selectedButton || { id: buttonId };
+  } else {
+    componentData = responseData;
+  }
+  const toolId = originalConfig?.tool_id;
+  const payload = JSON.stringify({
+    component_type: `receive_component_${componentName}`,
+    component_id: componentId,
+    component_data: componentData,
+    ...toolId && { tool_id: toolId }
+  });
+  return { method: rpcMethod, payload };
+}
+function formatDiseaseSubmission(componentId, selections) {
+  return {
+    method: "receive_dynamic_data",
+    payload: JSON.stringify({
+      component_type: "receive_component_disease_plans",
+      component_id: componentId,
+      selections
+    })
+  };
+}
+function formatDiseaseSearch(query) {
+  return {
+    method: "receive_dynamic_data",
+    payload: JSON.stringify({
+      component_type: "receive_component_disease_search",
+      query
+    })
+  };
+}
+function formatSlashCommand(command) {
+  return {
+    method: "receive_dynamic_data",
+    payload: JSON.stringify({
+      component_type: "receive_component_slash_command",
+      command: command.replace(/^\//, "")
+    })
+  };
+}
+
+exports.CallbackEventBus = CallbackEventBus;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.DEFAULT_WIDGET_THEME = DEFAULT_WIDGET_THEME;
+exports.DomEventBus = DomEventBus;
+exports.RinggApiClient = RinggApiClient;
+exports.StaticUrlResolver = StaticUrlResolver;
+exports.WIDGET_PRESET_THEMES = WIDGET_PRESET_THEMES;
+exports.WidgetStateController = WidgetStateController;
+exports.buildPayload = buildPayload;
+exports.colorToBackground = colorToBackground;
+exports.colorToBorder = colorToBorder;
+exports.colorToSolid = colorToSolid;
+exports.extractColorsFromGradient = extractColorsFromGradient;
+exports.filterSlashCommands = filterSlashCommands;
+exports.formatComponentResponse = formatComponentResponse;
+exports.formatDiseaseSearch = formatDiseaseSearch;
+exports.formatDiseaseSubmission = formatDiseaseSubmission;
+exports.formatSlashCommand = formatSlashCommand;
+exports.formatSlotDate = formatSlotDate;
+exports.formatSlotTime = formatSlotTime;
+exports.formatTimestamp = formatTimestamp;
+exports.getButtonRadius = getButtonRadius;
+exports.getContrastingTextColor = getContrastingTextColor;
+exports.getDiseasesWithSubQuestions = getDiseasesWithSubQuestions;
+exports.getDominantColor = getDominantColor;
+exports.groupSlotsByDate = groupSlotsByDate;
+exports.hasSubQuestions = hasSubQuestions;
+exports.isAgentIdentity = isAgentIdentity;
+exports.isButtons = isButtons;
+exports.isCalendarBooking = isCalendarBooking;
+exports.isConfirmation = isConfirmation;
+exports.isForm = isForm;
+exports.isGradient = isGradient;
+exports.isInteractiveFlow = isInteractiveFlow;
+exports.isLightColor = isLightColor;
+exports.mergeComponentTheme = mergeComponentTheme;
+exports.mergeWidgetTheme = mergeWidgetTheme;
+exports.transformRpcToComponent = transformRpcToComponent;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map