@robylon/whatsapp-react-sdk 1.0.0-staging.1

package/dist/umd/types/constants/errorConstants.d.ts

@@ -0,0 +1,60 @@
+export declare const ErrorCodes: {
+    readonly MISSING_API_KEY: "MISSING_API_KEY";
+    readonly INVALID_API_KEY: "INVALID_API_KEY";
+    readonly INVALID_USER_ID: "INVALID_USER_ID";
+    readonly CONFIG_FETCH_FAILED: "CONFIG_FETCH_FAILED";
+    readonly SDK_INIT_FAILED: "SDK_INIT_FAILED";
+    readonly ERROR_TRACKING_INIT_FAILED: "ERROR_TRACKING_INIT_FAILED";
+    readonly API_REQUEST_FAILED: "API_REQUEST_FAILED";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly INVALID_RESPONSE: "INVALID_RESPONSE";
+    readonly IFRAME_LOAD_FAILED: "IFRAME_LOAD_FAILED";
+    readonly MESSAGE_HANDLER_ERROR: "MESSAGE_HANDLER_ERROR";
+    readonly COOKIE_ACCESS_ERROR: "COOKIE_ACCESS_ERROR";
+    readonly COMPONENT_RENDER_ERROR: "COMPONENT_RENDER_ERROR";
+    readonly STATE_UPDATE_ERROR: "STATE_UPDATE_ERROR";
+};
+export declare const ErrorTypes: {
+    readonly INITIALIZATION_ERROR: "INITIALIZATION_ERROR";
+    readonly API_ERROR: "API_ERROR";
+    readonly RUNTIME_ERROR: "RUNTIME_ERROR";
+    readonly COMPONENT_ERROR: "COMPONENT_ERROR";
+};
+export declare const ErrorMessages: {
+    readonly MISSING_API_KEY: (providedValue?: any) => string;
+    readonly INVALID_API_KEY: (apiKey: string) => string;
+    readonly CONFIG_FETCH_FAILED: (details: {
+        statusCode?: number;
+        error?: string;
+    }) => string;
+    readonly API_REQUEST_FAILED: (status: number, message: string, endpoint?: string) => string;
+    readonly NETWORK_ERROR: (details: {
+        url?: string;
+        error?: string;
+    }) => string;
+    readonly IFRAME_LOAD_FAILED: (details: {
+        src?: string;
+        error?: string;
+    }) => string;
+    readonly INVALID_RESPONSE: (missingFields: string[]) => string;
+    readonly ERROR_TRACKING_INIT_FAILED: (details: {
+        apiKey?: string;
+        error?: string;
+    }) => string;
+    readonly SDK_INIT_FAILED: (details: {
+        reason?: string;
+        config?: Record<string, any>;
+    }) => string;
+    readonly COOKIE_ACCESS_ERROR: (operation: string, cookieName?: string) => string;
+    readonly COMPONENT_RENDER_ERROR: (details: {
+        component?: string | null | undefined;
+        error: string;
+        stack?: string | null;
+    }) => string;
+};
+export interface ErrorDetails {
+    errorCode: keyof typeof ErrorCodes;
+    errorType: keyof typeof ErrorTypes;
+    context?: Record<string, any>;
+    originalError?: any;
+}

package/dist/umd/types/constants/fontStyles.d.ts

@@ -0,0 +1,4 @@
+export declare const FONT_FAMILY = "system-ui, Inter, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'";
+/** Chat widget popup: same stack as FONT_FAMILY with trailing generic + !important via scoped CSS */
+export declare const CHAT_WIDGET_POPUP_FONT_FAMILY = "system-ui, Inter, \"Segoe UI\", Roboto, Helvetica, Arial, sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\", sans-serif";
+export declare const FONT_LINE_HEIGHT = "21px";

package/dist/umd/types/core/api.d.ts

@@ -0,0 +1,10 @@
+export declare const USE_WHATSAPP_MOCK_API = false;
+export declare const normalizeWhatsappGetResponse: (data: any) => any;
+/**
+ * Fetches the chatbot configuration from the API
+ * @param apiKey The API key for the chatbot
+ * @param userId The user ID (optional)
+ * @param userToken The user token (optional)
+ * @returns The chatbot configuration
+ */
+export declare const fetchChatbotConfig: (apiKey: string, userId?: string, userToken?: string) => Promise<any>;

package/dist/umd/types/core/config.d.ts

@@ -0,0 +1,41 @@
+import { ChatbotConfig } from "../types";
+import { ProactiveMessage } from "src/types";
+/**
+ * Normalizes the configuration properties
+ * @param props The configuration properties
+ * @returns Normalized configuration properties
+ */
+export declare const normalizeProps: (props: {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}) => {
+    api_key: string;
+    user_id: string | null;
+    user_token: string | undefined;
+    user_profile: Record<string, any>;
+};
+/**
+ * Normalizes the user profile by filtering allowed keys and converting values
+ * @param userProfile The user profile object
+ * @returns Normalized user profile
+ */
+export declare const normalizeUserProfile: (userProfile?: Record<string, any>) => any;
+/**
+ * Initializes the chatbot configuration
+ * @param props The configuration properties
+ * @returns The initialized chatbot configuration
+ */
+export declare const initializeChatbotConfig: (props: {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}) => Promise<ChatbotConfig>;
+/**
+ * Normalizes proactive messages from backend to an array form, preserving order.
+ * - Accepts undefined, single object, or array of objects
+ * - Migrates legacy `content` to `content_multiple`
+ */
+export declare const normalizeProactiveMessages: (input: any) => ProactiveMessage[] | undefined;

package/dist/umd/types/core/events.d.ts

@@ -0,0 +1,22 @@
+import { ChatbotEvent, ChatbotEventType, AllEventTypes } from "../types/events";
+/**
+ * Event emitter interface for handling chatbot events
+ */
+export interface EventEmitter {
+    emit: (eventType: ChatbotEventType, data?: any) => void;
+    onInternalEvent: (eventType: AllEventTypes, additionalData?: Record<string, any>) => void;
+}
+/**
+ * Creates an event emitter for handling chatbot events
+ * @param props Configuration for the event emitter
+ * @returns An event emitter object
+ */
+export declare const createEventEmitter: (props: {
+    api_key: string;
+    user_profile?: Record<string, any>;
+    onEvent?: (event: ChatbotEvent) => void;
+    chatbotConfig?: {
+        isAnonymous?: boolean;
+        userId?: string | null | number;
+    } | null;
+}) => EventEmitter;

package/dist/umd/types/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./api";
+export * from "./config";
+export * from "./events";
+export * from "./state";

package/dist/umd/types/core/state.d.ts

@@ -0,0 +1,34 @@
+import { ChatbotConfig } from "../types";
+/**
+ * Interface for the chatbot state
+ */
+export interface ChatbotState {
+    isInitialized: boolean;
+    isInitializing: boolean;
+    error: string | null;
+    chatbotConfig: ChatbotConfig | null;
+    isIframeVisible: boolean;
+}
+/**
+ * Interface for the chatbot state manager
+ */
+export interface ChatbotStateManager {
+    getState: () => ChatbotState;
+    initialize: () => Promise<void>;
+    toggleIframeVisibility: () => void;
+    closeIframe: () => void;
+    updateState: (partialState: Partial<ChatbotState>) => void;
+    subscribe: (listener: (state: ChatbotState) => void) => () => void;
+    unsubscribe: (listener: (state: ChatbotState) => void) => void;
+}
+/**
+ * Creates a state manager for the chatbot
+ * @param props Configuration properties
+ * @returns A state manager object
+ */
+export declare const createChatbotStateManager: (props: {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}) => ChatbotStateManager;

package/dist/umd/types/hooks/useChatbot.d.ts

@@ -0,0 +1,2 @@
+import { ChatbotConfig, ChatbotState } from "../types";
+export declare const useChatbot: (config: ChatbotConfig) => ChatbotState;

package/dist/umd/types/hooks/useChatbotEvents.d.ts

@@ -0,0 +1,12 @@
+import { ChatbotEventType, AllEventTypes, ChatbotEventHandler } from "../types/events";
+interface EventHookProps {
+    api_key: string;
+    chatbotConfig: any;
+    user_profile?: Record<string, any>;
+    onEvent?: ChatbotEventHandler;
+}
+export declare const useChatbotEvents: ({ api_key, chatbotConfig, user_profile, onEvent, }: EventHookProps) => {
+    emitEvent: (type: ChatbotEventType, data?: any) => void;
+    onInternalEvent: (eventType: AllEventTypes, additionalData?: Record<string, any>) => Promise<void>;
+};
+export {};

package/dist/umd/types/hooks/useChatbotState.d.ts

@@ -0,0 +1,16 @@
+interface ChatbotStateProps {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}
+export declare const useChatbotState: (rawProps: ChatbotStateProps) => {
+    toggleIframeVisibility: () => void;
+    closeIframe: () => void;
+    isInitialized: boolean;
+    isInitializing: boolean;
+    error: string | null;
+    chatbotConfig: any;
+    isIframeVisible: boolean;
+};
+export {};

package/dist/umd/types/hooks/useWhyDidYouUpdate.d.ts

@@ -0,0 +1,5 @@
+type PropsWithKeyString = {
+    [key: string]: any;
+};
+export declare function useWhyDidYouUpdate(name: string, props: PropsWithKeyString): void;
+export {};

package/dist/umd/types/index.d.ts

@@ -0,0 +1,6 @@
+export { Chatbot } from "./components/RobylonChatbot";
+export * from "./types";
+export * from "./hooks/useChatbot";
+export { ChatbotRef } from "./types/events";
+import RobylonChatbot from "./vanilla";
+export { RobylonChatbot };

package/dist/umd/types/services/ErrorTrackingService.d.ts

@@ -0,0 +1,38 @@
+export declare enum EventType {
+    ERROR = "ERROR",
+    INFO = "INFO"
+}
+export interface ErrorEventData {
+    message: string;
+    stack?: string;
+    componentName?: string | null | undefined;
+    additionalInfo?: Record<string, any>;
+    timestamp: number;
+}
+export interface LogPayload {
+    org_id: string;
+    event_data: ErrorEventData;
+    metadata: Record<string, any>;
+    event_type: EventType;
+    user_id?: string | number | null;
+}
+declare class ErrorTrackingService {
+    private static instance;
+    private apiKey;
+    private userId;
+    private preInitQueue;
+    private isInitialized;
+    private constructor();
+    private handleWindowError;
+    private handleUnhandledRejection;
+    private setupGlobalHandlers;
+    cleanup(): void;
+    static getInstance(): ErrorTrackingService;
+    initialize(apiKey: string, userId?: string | number | null): void;
+    private processPreInitQueue;
+    private sendLog;
+    trackError(error: Error | string, componentName: string | null | undefined, additionalInfo?: Record<string, any>): Promise<void>;
+    trackInfo(message: string, componentName: string | null | undefined, additionalInfo?: Record<string, any>): Promise<void>;
+}
+export declare const errorTracker: ErrorTrackingService;
+export {};

package/dist/umd/types/types/events.d.ts

@@ -0,0 +1,29 @@
+export declare enum ChatbotEventType {
+    CHATBOT_BUTTON_LOADED = "CHATBOT_BUTTON_LOADED",// Internal SDK event
+    CHATBOT_BUTTON_CLICKED = "CHATBOT_BUTTON_CLICKED",// Internal SDK event
+    CHATBOT_OPENED = "CHATBOT_OPENED",// Internal SDK event
+    CHATBOT_CLOSED = "CHATBOT_CLOSED",// Internal SDK event
+    CHATBOT_APP_READY = "CHATBOT_APP_READY",// Internal SDK event
+    CHATBOT_LOADED = "CHATBOT_LOADED",// From Robylon Chatbot
+    CHAT_INITIALIZED = "CHAT_INITIALIZED",// From Robylon Chatbot
+    SESSION_REFRESHED = "SESSION_REFRESHED",// From Robylon Chatbot
+    CHAT_INITIALIZATION_FAILED = "CHAT_INITIALIZATION_FAILED",// From Robylon Chatbot
+    CHATBOT_READY = "CHATBOT_READY"
+}
+export declare enum InternalEventType {
+    CHAT_MOVED = "CHAT_MOVED",// Internal only event
+    CHATBOT_TOKEN_EXHAUSTED = "CHATBOT_TOKEN_EXHAUSTED"
+}
+export type AllEventTypes = ChatbotEventType | InternalEventType;
+export interface ChatbotEvent {
+    type: ChatbotEventType;
+    timestamp: number;
+    data?: any;
+}
+export type ChatbotEventHandler = (event: ChatbotEvent) => void;
+export interface ChatbotRef {
+    show: () => void;
+    hide: () => void;
+    toggle: () => void;
+    isReady: boolean;
+}

package/dist/umd/types/types/state.d.ts

@@ -0,0 +1,5 @@
+export interface ChatbotState {
+    isLoading: boolean;
+    isInitialized: boolean;
+    error: string | null;
+}

package/dist/umd/types/types.d.ts

@@ -0,0 +1,137 @@
+export declare enum ChatbotInterfaceType {
+    WIDGET = "WIDGET",
+    POPOVER = "POPOVER",
+    EMBED = "EMBED"
+}
+export declare enum WidgetPositionEnums {
+    RIGHT = "Right",
+    LEFT = "Left"
+}
+export interface WidgetInterfaceProperties {
+    position: WidgetPositionEnums;
+    side_spacing?: number;
+    bottom_spacing?: number;
+}
+export declare enum LauncherType {
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    TEXTUAL_IMAGE = "TEXTUAL_IMAGE"
+}
+export interface ChatbotConfig {
+    chatbotId: string;
+    userId: string | null | number;
+    token?: string;
+    userProfile?: Record<string, any>;
+    domain: string;
+    show_launcher: boolean;
+    brand_colour: string;
+    image_url?: string;
+    chat_interface_config?: {
+        chat_bubble_prompts?: string[];
+        display_name?: string;
+        welcome_message?: string;
+        redirect_url?: string;
+    };
+    isAnonymous?: boolean;
+    interface_type?: ChatbotInterfaceType;
+    interface_properties?: WidgetInterfaceProperties;
+    launcher_type: LauncherType;
+    launcher_properties: {
+        text?: string;
+    };
+    images: {
+        launcher_image_url?: {
+            url: string;
+        };
+    };
+    proactive_message_obj?: ProactiveMessage[] | undefined;
+    launcher_delay: {
+        enabled: boolean;
+        delay: number;
+    };
+    launcher_size_multiplier?: number;
+    redirect_chat_link?: string;
+    pre_filled_message?: string;
+    widget_type?: string;
+    widget_title?: string;
+    widget_subtitle?: string;
+    title_bar_color?: string;
+    button_content?: string;
+    powered_by_robylon?: boolean;
+}
+interface RobylonSdkConfig {
+    chatbot_id: string;
+    user_id: string;
+    token?: string;
+    user_profile?: {
+        email?: string;
+        name?: string;
+        mobile?: string;
+        platform: string;
+        OS: string;
+        browser: string;
+        sdk_version: string;
+    };
+}
+export interface ChatbotState {
+    isLoading: boolean;
+    isInitialized: boolean;
+    error: string | null;
+}
+declare global {
+    interface Window {
+        initializeRobylonSdk: (config: RobylonSdkConfig) => void;
+    }
+}
+export declare enum ProactiveSendTimeType {
+    WORKING_HOURS = "WORKING_HOURS",
+    ALWAYS = "ALWAYS"
+}
+export declare enum DisplayAttributesType {
+    "URL" = "URL"
+}
+export declare enum LogicalConditionType {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum ConditionType {
+    IS = "IS",
+    IS_NOT = "IS_NOT",
+    CONTAINS = "CONTAINS",
+    DOES_NOT_CONTAIN = "DOES_NOT_CONTAIN",
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH"
+}
+export declare enum MessageDisplayType {
+    BUTTON = "BUTTON",
+    TEXT = "TEXT"
+}
+export interface ContentDisplayAttribute {
+    type: DisplayAttributesType;
+    value: string;
+    condition: ConditionType;
+}
+export interface LogicalConditionAttribute {
+    logical_condition: LogicalConditionType;
+}
+export interface ProactiveMessage {
+    message_id: string;
+    org_id: string;
+    name?: string;
+    content?: string;
+    send_time_type?: ProactiveSendTimeType | string;
+    created_by_name?: string;
+    updated_by_name?: string;
+    updated_at?: string;
+    created_at?: string;
+    delay?: number;
+    content_multiple?: {
+        message: string;
+        content_id?: string;
+        message_display_type?: MessageDisplayType;
+        message_bubble_bg?: string;
+        url_to_go?: string;
+        message_display_attributes: (ContentDisplayAttribute | LogicalConditionAttribute)[];
+    }[];
+}
+export {};

package/dist/umd/types/utils/chatbotSdk.d.ts

@@ -0,0 +1,23 @@
+import { ChatbotConfig } from "../types";
+export declare class ChatbotEmbed {
+    private config;
+    private logoContainer;
+    private iframe;
+    private bubblePromptContainer;
+    private chatBtnImage;
+    constructor(config: ChatbotConfig);
+    private onCloseListener;
+    private validateDomain;
+    private createChatBubblContainer;
+    private createMessageBubble;
+    private createFloatingButton;
+    private loadImage;
+    private createIframe;
+    private adjustIframeWidth;
+    private loadSvgInline;
+    private toggleIcon;
+    private toggleIframe;
+    private closeIframe;
+    init(): void;
+}
+export declare const initializeRobylonSdk: (config: ChatbotConfig, setIsInitialized: (value: boolean) => void, setError: (error: string | null) => void) => void;

package/dist/umd/types/utils/colorUtils.d.ts

@@ -0,0 +1 @@
+export declare const getBestFontColor: (backgroundColor: string, contrastThreshold?: number) => string;

package/dist/umd/types/utils/cookieUtils.d.ts

@@ -0,0 +1,6 @@
+export declare const generateUUID: () => string;
+export declare const getCookie: (name: string) => string | undefined;
+export declare const setCookie: (name: string, value: string, days: number) => void;
+export declare const getLocalStorage: () => string;
+export declare const getSessionStorage: () => string;
+export declare const getCookies: (isTeachmint: boolean) => any;

package/dist/umd/types/utils/environment.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks if code is running in a browser environment
+ */
+export declare const isBrowser: () => boolean;
+/**
+ * Gets environment configuration
+ */
+export declare const getEnvironmentConfig: () => {
+    copilotUrl: string;
+    environment: string;
+    apiUrl: string;
+};

package/dist/umd/types/utils/fetchData.d.ts

@@ -0,0 +1,53 @@
+import { ChatbotInterfaceType, LauncherType, WidgetPositionEnums, ProactiveMessage } from "../types";
+interface ChatbotResponse {
+    user: {
+        token: string;
+        user_info: {
+            email: string;
+            user_id: string;
+            name: string;
+        };
+        org_info: {
+            org_id: string;
+            org_name: string;
+            role: string;
+            auth_status: string;
+            domain: string;
+            brand_config: {
+                display_name: string;
+                redirect_url: string;
+                colors?: {
+                    brand_color: string;
+                    title_bar_color?: string;
+                };
+                launcher_logo_url?: string;
+                welcome_message: string;
+                image_url: string;
+                interface_properties: {
+                    position: WidgetPositionEnums;
+                    side_spacing: number;
+                    bottom_spacing: number;
+                };
+                interface_type: ChatbotInterfaceType;
+                launcher_type: LauncherType;
+                launcher_properties: {
+                    text: string;
+                };
+                images: {
+                    launcher_image_url: {
+                        url: string;
+                    };
+                };
+                proactive_message_obj?: ProactiveMessage | ProactiveMessage[];
+                launcher_delay: {
+                    enabled: boolean;
+                    delay: number;
+                };
+                launcher_size_multiplier?: number;
+            };
+            show_launcher: boolean;
+        };
+    };
+}
+export declare const fetchChatbotConfig: (chatbotId: string, userId: string | null | number, token?: string) => Promise<ChatbotResponse>;
+export {};

package/dist/umd/types/utils/launcherInfo.d.ts

@@ -0,0 +1,11 @@
+import { SystemInfo } from "./systemInfo";
+interface LauncherInfo {
+    current_page_url: string;
+    browser_language: string;
+    browser_version: string;
+    os: string;
+    referral_url: string;
+    system_info?: SystemInfo;
+}
+export declare const getLauncherInfo: () => LauncherInfo;
+export {};

package/dist/umd/types/utils/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};

package/dist/umd/types/utils/misc.d.ts

@@ -0,0 +1 @@
+export declare function generateUUID(): string;

package/dist/umd/types/utils/originalFetchDataFile.d.ts

@@ -0,0 +1 @@
+export declare const originalFetchData: (url: string, payload: any) => Promise<any>;

package/dist/umd/types/utils/proactive.d.ts

@@ -0,0 +1,25 @@
+import { ProactiveMessage, MessageDisplayType } from "src/types";
+export declare const hideProactiveForThisPage: () => void;
+export declare const isProactiveHiddenThisPage: () => boolean;
+export declare const setLastClickedProactive: (params: {
+    content_string: string | null;
+    message_id: string | null;
+    content_id: string | null;
+}) => void;
+export declare const getAndClearLastClickedProactive: () => {
+    input_id: null;
+    content_string: string | null;
+    message_id: string | null;
+    content_id?: string | null;
+} | null;
+export interface VisibleContent {
+    messageId: string;
+    contentIndex: number;
+    html: string;
+    delayMs: number;
+    contentId: string | null;
+    messageDisplayType: MessageDisplayType;
+    messageBubbleBg?: string;
+    urlToGo?: string;
+}
+export declare const evaluateProactiveMessages: (messages?: ProactiveMessage[]) => VisibleContent[];

package/dist/umd/types/utils/sanitize.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sanitizes HTML while preserving emojis and basic inline formatting.
+ */
+export declare const sanitizeHtml: (html?: string) => string;

package/dist/umd/types/utils/systemInfo.d.ts

@@ -0,0 +1,12 @@
+export interface SystemInfo {
+    platform: string;
+    os: string;
+    browser: string;
+    sdk_version: string;
+    device: string;
+    screen_size: {
+        width: number;
+        height: number;
+    };
+}
+export declare const getSystemInfo: () => SystemInfo;

package/dist/umd/types/utils/textDirection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Detects if text contains RTL (Right-to-Left) characters
+ * Supports Arabic, Hebrew, Persian/Farsi, Urdu, Yiddish, and other RTL scripts
+ * @param text - The text to analyze
+ * @returns "rtl" if RTL characters are dominant, "ltr" otherwise
+ */
+export declare function detectTextDirection(text?: string): 'rtl' | 'ltr';

package/dist/umd/types/utils/url.d.ts

@@ -0,0 +1,8 @@
+import { ConditionType, DisplayAttributesType } from "src/types";
+type UrlChangeListener = (href: string) => void;
+export declare const getCurrentHref: () => string;
+export declare const buildLocationKey: () => string;
+export declare const subscribeToUrlChanges: (cb: UrlChangeListener) => (() => void);
+export declare const initUrlObserver: () => void;
+export declare const matchCondition: (type: DisplayAttributesType, value: string, condition: ConditionType, href: string) => boolean;
+export {};

package/dist/umd/types/utils/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION: string;

package/dist/umd/types/vanilla/components/ChatWidgetPopup.d.ts

@@ -0,0 +1,17 @@
+import { ChatbotConfig } from "../../types";
+interface ChatWidgetPopupConfig {
+    config: ChatbotConfig;
+    onCtaClick: () => void;
+}
+export declare class ChatWidgetPopup {
+    private popupElement;
+    private config;
+    constructor(config: ChatWidgetPopupConfig);
+    private createTitleBar;
+    private createContent;
+    private render;
+    getElement(): HTMLDivElement;
+    update(config: ChatWidgetPopupConfig): void;
+    destroy(): void;
+}
+export {};