@weldsuite/helpdesk-widget-sdk 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,1428 @@
+/**
+ * Weld SDK - Configuration Types
+ * Type definitions for SDK initialization and configuration
+ */
+/**
+ * Event types for widget events
+ */
+type WidgetEventType = 'ready' | 'open' | 'close' | 'error' | 'message' | 'minimize' | 'maximize' | 'destroy';
+/**
+ * Widget event structure
+ */
+interface WidgetEvent {
+    type: WidgetEventType;
+    data?: any;
+    timestamp: number;
+}
+/**
+ * Event handler function type
+ */
+type WidgetEventHandler = (event?: WidgetEvent | any) => void;
+/**
+ * Position configuration
+ */
+interface PositionConfig {
+    bottom?: string;
+    right?: string;
+    left?: string;
+    top?: string;
+}
+/**
+ * Customization configuration
+ */
+interface CustomizationConfig {
+    primaryColor?: string;
+    accentColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    borderRadius?: string;
+}
+/**
+ * Feature flags
+ */
+interface FeatureConfig {
+    attachments?: boolean;
+    reactions?: boolean;
+    typing?: boolean;
+    readReceipts?: boolean;
+    offlineMode?: boolean;
+    fileUpload?: boolean;
+    imageUpload?: boolean;
+    voiceMessages?: boolean;
+    videoMessages?: boolean;
+}
+/**
+ * Mobile configuration
+ */
+interface MobileConfig {
+    fullScreen?: boolean;
+    scrollLock?: boolean;
+    keyboardHandling?: 'auto' | 'manual';
+    safeAreaInsets?: boolean;
+}
+/**
+ * Iframe configuration
+ */
+interface IframeConfig {
+    launcher: {
+        url: string;
+        name: string;
+        position: PositionConfig;
+        size: string;
+    };
+    widget: {
+        url: string;
+        name: string;
+        position: PositionConfig;
+        width: string;
+        height: string;
+    };
+    backdrop?: {
+        enabled: boolean;
+        closeOnClick: boolean;
+    };
+}
+/**
+ * API configuration
+ */
+interface ApiConfig {
+    baseUrl: string;
+    widgetId: string;
+    endpoints?: {
+        messages?: string;
+        users?: string;
+        conversations?: string;
+        upload?: string;
+    };
+    timeout?: number;
+    retries?: number;
+}
+/**
+ * Authentication configuration
+ */
+interface AuthConfig {
+    enabled?: boolean;
+    mode?: 'anonymous' | 'identified';
+    userId?: string;
+    email?: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+    token?: string;
+}
+/**
+ * Locale configuration
+ */
+interface LocaleConfig {
+    locale?: string;
+    translations?: Record<string, Record<string, string>>;
+    dateFormat?: string;
+    timeFormat?: string;
+    timezone?: string;
+}
+/**
+ * Logging configuration
+ */
+interface LogConfig {
+    enabled?: boolean;
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    prefix?: string;
+    includeTimestamp?: boolean;
+}
+/**
+ * Performance configuration
+ */
+interface PerformanceConfig {
+    lazyLoad?: boolean;
+    preload?: boolean;
+    caching?: boolean;
+    prefetch?: boolean;
+}
+/**
+ * Security configuration
+ */
+interface SecurityConfig {
+    allowedOrigins?: string[];
+    validateMessages?: boolean;
+    sanitizeInput?: boolean;
+    contentSecurityPolicy?: string;
+}
+/**
+ * Main SDK configuration
+ */
+interface WeldConfig {
+    widgetId: string;
+    api?: Partial<ApiConfig>;
+    iframes?: Partial<IframeConfig>;
+    position?: {
+        launcher?: PositionConfig;
+        widget?: PositionConfig;
+    };
+    customization?: CustomizationConfig;
+    features?: FeatureConfig;
+    mobile?: MobileConfig;
+    auth?: AuthConfig;
+    locale?: LocaleConfig;
+    logging?: LogConfig;
+    performance?: PerformanceConfig;
+    security?: SecurityConfig;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onMessage?: (message: any) => void;
+    onMinimize?: () => void;
+    onMaximize?: () => void;
+    onDestroy?: () => void;
+}
+/**
+ * Runtime configuration (resolved from WeldConfig)
+ */
+interface ResolvedConfig {
+    widgetId: string;
+    api: ApiConfig;
+    iframes: IframeConfig;
+    customization: CustomizationConfig;
+    features: FeatureConfig;
+    mobile: MobileConfig;
+    auth: AuthConfig;
+    locale: LocaleConfig;
+    logging: LogConfig;
+    performance: PerformanceConfig;
+    security: SecurityConfig;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onMessage?: (message: any) => void;
+    onMinimize?: () => void;
+    onMaximize?: () => void;
+    onDestroy?: () => void;
+}
+/**
+ * Device detection
+ */
+type DeviceType = 'mobile' | 'tablet' | 'desktop';
+interface DeviceInfo {
+    type: DeviceType;
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isTouchDevice: boolean;
+    screenWidth: number;
+    screenHeight: number;
+    orientation: 'portrait' | 'landscape';
+    userAgent: string;
+}
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_CONFIG: Omit<ResolvedConfig, 'widgetId'>;
+/**
+ * Configuration validation
+ */
+declare function validateConfig(config: Partial<WeldConfig>): boolean;
+/**
+ * Merge configuration with defaults
+ */
+declare function resolveConfig(config: WeldConfig): ResolvedConfig;
+
+/**
+ * Weld SDK - State Types
+ * Type definitions for state management across iframes
+ */
+/**
+ * Widget visibility state
+ */
+declare enum WidgetVisibility {
+    HIDDEN = "hidden",
+    VISIBLE = "visible",
+    MINIMIZED = "minimized"
+}
+/**
+ * Widget view types
+ */
+declare enum WidgetView {
+    HOME = "home",
+    CONVERSATION = "conversation",
+    CONVERSATIONS = "conversations",
+    HELP = "help",
+    SETTINGS = "settings",
+    SEARCH = "search"
+}
+/**
+ * Connection status
+ */
+declare enum ConnectionStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    ERROR = "error"
+}
+/**
+ * Message status
+ */
+declare enum MessageStatus {
+    SENDING = "sending",
+    SENT = "sent",
+    DELIVERED = "delivered",
+    READ = "read",
+    FAILED = "failed"
+}
+/**
+ * User state
+ */
+interface UserState {
+    id?: string;
+    email?: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+    isAuthenticated: boolean;
+    isAnonymous: boolean;
+}
+/**
+ * Conversation state
+ */
+interface ConversationState {
+    id?: string;
+    messages: Message[];
+    participants: Participant[];
+    unreadCount: number;
+    lastMessageAt?: number;
+    isTyping: boolean;
+    typingUsers: string[];
+}
+/**
+ * Message interface
+ */
+interface Message {
+    id: string;
+    conversationId: string;
+    text: string;
+    sender: {
+        id: string;
+        name: string;
+        avatar?: string;
+        type: 'user' | 'agent' | 'bot';
+    };
+    status: MessageStatus;
+    timestamp: number;
+    createdAt: number;
+    updatedAt?: number;
+    attachments?: Attachment[];
+    reactions?: Reaction[];
+    metadata?: Record<string, any>;
+}
+/**
+ * Attachment interface
+ */
+interface Attachment {
+    id: string;
+    type: 'image' | 'file' | 'video' | 'audio';
+    url: string;
+    name: string;
+    size: number;
+    mimeType: string;
+    thumbnail?: string;
+}
+/**
+ * Reaction interface
+ */
+interface Reaction {
+    emoji: string;
+    count: number;
+    users: string[];
+}
+/**
+ * Participant interface
+ */
+interface Participant {
+    id: string;
+    name: string;
+    avatar?: string;
+    type: 'user' | 'agent' | 'bot';
+    isOnline: boolean;
+    lastSeenAt?: number;
+}
+/**
+ * Widget state
+ */
+interface WidgetState {
+    visibility: WidgetVisibility;
+    view: WidgetView;
+    isOpen: boolean;
+    isMinimized: boolean;
+    dimensions: {
+        width: string;
+        height: string;
+    };
+    position: {
+        bottom: string;
+        right: string;
+    };
+}
+/**
+ * Launcher state
+ */
+interface LauncherState {
+    isVisible: boolean;
+    badge: {
+        count: number;
+        text?: string;
+        show: boolean;
+    };
+    customColor?: string;
+    tooltip?: string;
+}
+/**
+ * Backdrop state
+ */
+interface BackdropState {
+    isVisible: boolean;
+    closeOnClick: boolean;
+    opacity: number;
+}
+/**
+ * Mobile state
+ */
+interface MobileState {
+    isFullScreen: boolean;
+    isScrollLocked: boolean;
+    keyboardHeight: number;
+    orientation: 'portrait' | 'landscape';
+    safeAreaInsets: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+/**
+ * Network state
+ */
+interface NetworkState {
+    status: ConnectionStatus;
+    lastConnected?: number;
+    retryCount: number;
+    latency?: number;
+}
+/**
+ * UI state
+ */
+interface UIState {
+    theme: 'light' | 'dark' | 'auto';
+    locale: string;
+    isLoading: boolean;
+    error?: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    };
+}
+/**
+ * Main application state
+ */
+interface WeldState {
+    user: UserState;
+    conversation: ConversationState;
+    widget: WidgetState;
+    launcher: LauncherState;
+    backdrop: BackdropState;
+    mobile: MobileState;
+    network: NetworkState;
+    ui: UIState;
+    initialized: boolean;
+    lastUpdated: number;
+}
+/**
+ * State update action
+ */
+interface StateAction<T = any> {
+    type: string;
+    path: keyof WeldState | string;
+    payload: T;
+    merge?: boolean;
+    timestamp: number;
+}
+/**
+ * State listener callback
+ */
+type StateListener<T = any> = (newState: T, oldState: T) => void;
+/**
+ * State subscription
+ */
+interface StateSubscription {
+    id: string;
+    path: string;
+    listener: StateListener;
+    immediate?: boolean;
+}
+/**
+ * Initial state factory
+ */
+declare function createInitialState(): WeldState;
+/**
+ * State path utility
+ */
+declare function getStateValue<T = any>(state: WeldState, path: string): T;
+/**
+ * State update utility
+ */
+declare function setStateValue(state: WeldState, path: string, value: any, merge?: boolean): WeldState;
+
+/**
+ * User identification data
+ */
+interface UserIdentity {
+    userId: string;
+    email?: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * WeldSDK class
+ * Main SDK interface for embedding the widget
+ */
+declare class WeldSDK {
+    private config;
+    private logger;
+    private iframeManager;
+    private messageBroker;
+    private stateCoordinator;
+    private status;
+    private readyPromise;
+    private readyResolve;
+    constructor(config: WeldConfig);
+    /**
+     * Initialize the SDK and render widget
+     */
+    init(): Promise<void>;
+    /**
+     * Setup ready message handlers
+     */
+    private setupReadyHandlers;
+    /**
+     * Map iframe name to type
+     */
+    private mapIframeNameToType;
+    /**
+     * Wait for all iframes to be ready
+     */
+    private waitForIframesReady;
+    /**
+     * Wait for SDK to be ready
+     */
+    ready(): Promise<void>;
+    /**
+     * Check if SDK is ready
+     */
+    isReady(): boolean;
+    /**
+     * Open the widget
+     */
+    open(): void;
+    /**
+     * Close the widget
+     */
+    close(): void;
+    /**
+     * Toggle widget open/close
+     */
+    toggle(): void;
+    /**
+     * Minimize the widget
+     */
+    minimize(): void;
+    /**
+     * Maximize the widget
+     */
+    maximize(): void;
+    /**
+     * Show the launcher
+     */
+    showLauncher(): void;
+    /**
+     * Hide the launcher
+     */
+    hideLauncher(): void;
+    /**
+     * Set badge count
+     */
+    setBadgeCount(count: number): void;
+    /**
+     * Clear badge
+     */
+    clearBadge(): void;
+    /**
+     * Send a message
+     */
+    sendMessage(text: string, metadata?: Record<string, any>): void;
+    /**
+     * Identify user
+     */
+    identify(identity: UserIdentity): void;
+    /**
+     * Logout user
+     */
+    logout(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<WeldConfig>): void;
+    /**
+     * Update theme
+     */
+    setTheme(theme: 'light' | 'dark' | 'auto'): void;
+    /**
+     * Update locale
+     */
+    setLocale(locale: string): void;
+    /**
+     * Track custom event
+     */
+    track(eventName: string, properties?: Record<string, any>): void;
+    /**
+     * Get current state
+     */
+    getState(): WeldState;
+    /**
+     * Subscribe to state changes
+     */
+    onStateChange<T = any>(path: string, listener: (newValue: T, oldValue: T) => void): () => void;
+    /**
+     * Get device info
+     */
+    getDeviceInfo(): DeviceInfo;
+    /**
+     * Get SDK status
+     */
+    getStatus(): string;
+    /**
+     * Get SDK version
+     */
+    getVersion(): string;
+    /**
+     * Enable debug mode
+     */
+    enableDebug(): void;
+    /**
+     * Disable debug mode
+     */
+    disableDebug(): void;
+    /**
+     * Ensure SDK is ready before operation
+     */
+    private ensureReady;
+    /**
+     * Destroy SDK and cleanup
+     */
+    destroy(): void;
+}
+/**
+ * Create and initialize WeldSDK instance
+ */
+declare function createWeldSDK(config: WeldConfig): Promise<WeldSDK>;
+
+/**
+ * Weld SDK - Iframe Manager
+ * Manages creation, lifecycle, and communication with multiple iframes
+ */
+
+/**
+ * Iframe types
+ */
+declare enum IframeType {
+    LAUNCHER = "launcher",
+    WIDGET = "widget",
+    BACKDROP = "backdrop"
+}
+/**
+ * Iframe metadata
+ */
+interface IframeMetadata {
+    type: IframeType;
+    element: HTMLIFrameElement;
+    container: HTMLDivElement;
+    ready: boolean;
+    visible: boolean;
+    createdAt: number;
+}
+/**
+ * IframeManager class
+ * Orchestrates multiple iframes for the widget system
+ */
+declare class IframeManager {
+    private config;
+    private logger;
+    private iframes;
+    private rootContainer;
+    private appContainer;
+    private modalContainer;
+    private deviceInfo;
+    private styleElement;
+    constructor(config: ResolvedConfig);
+    /**
+     * Initialize all containers and iframes
+     */
+    init(): Promise<void>;
+    /**
+     * Create root container structure
+     */
+    private createRootContainer;
+    /**
+     * Inject CSS into the page
+     */
+    private injectCSS;
+    /**
+     * Generate CSS for containers
+     */
+    private generateCSS;
+    /**
+     * Create launcher iframe
+     */
+    private createLauncherIframe;
+    /**
+     * Create widget iframe
+     */
+    private createWidgetIframe;
+    /**
+     * Create backdrop iframe
+     */
+    private createBackdropIframe;
+    /**
+     * Build iframe URL with parameters
+     */
+    private buildIframeUrl;
+    /**
+     * Setup event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Handle window resize
+     */
+    private handleResize;
+    /**
+     * Handle orientation change
+     */
+    private handleOrientationChange;
+    /**
+     * Get iframe by type
+     */
+    getIframe(type: IframeType): IframeMetadata | undefined;
+    /**
+     * Get iframe element
+     */
+    getIframeElement(type: IframeType): HTMLIFrameElement | undefined;
+    /**
+     * Get iframe container
+     */
+    getIframeContainer(type: IframeType): HTMLDivElement | undefined;
+    /**
+     * Mark iframe as ready
+     */
+    setIframeReady(type: IframeType): void;
+    /**
+     * Check if all iframes are ready
+     */
+    areAllIframesReady(): boolean;
+    /**
+     * Show iframe
+     */
+    showIframe(type: IframeType): void;
+    /**
+     * Hide iframe
+     */
+    hideIframe(type: IframeType): void;
+    /**
+     * Get device info
+     */
+    getDeviceInfo(): DeviceInfo;
+    /**
+     * Get modal container
+     */
+    getModalContainer(): HTMLDivElement | null;
+    /**
+     * Destroy all iframes and cleanup
+     */
+    destroy(): void;
+}
+
+/**
+ * Weld SDK - Message Types
+ * Type definitions for postMessage communication between parent and iframes
+ */
+/**
+ * Message origins for validation
+ */
+declare enum MessageOrigin {
+    LAUNCHER = "launcher",
+    WIDGET = "widget",
+    PARENT = "parent",
+    BACKDROP = "backdrop"
+}
+/**
+ * Message types for different communication patterns
+ */
+declare enum MessageType {
+    READY = "weld:ready",
+    INIT = "weld:init",
+    DESTROY = "weld:destroy",
+    STATE_UPDATE = "weld:state:update",
+    STATE_REQUEST = "weld:state:request",
+    STATE_RESPONSE = "weld:state:response",
+    WIDGET_OPEN = "weld:widget:open",
+    WIDGET_CLOSE = "weld:widget:close",
+    WIDGET_TOGGLE = "weld:widget:toggle",
+    WIDGET_MINIMIZE = "weld:widget:minimize",
+    WIDGET_MAXIMIZE = "weld:widget:maximize",
+    LAUNCHER_SHOW = "weld:launcher:show",
+    LAUNCHER_HIDE = "weld:launcher:hide",
+    LAUNCHER_UPDATE = "weld:launcher:update",
+    BACKDROP_SHOW = "weld:backdrop:show",
+    BACKDROP_HIDE = "weld:backdrop:hide",
+    BACKDROP_CLICK = "weld:backdrop:click",
+    MESSAGE_SEND = "weld:message:send",
+    MESSAGE_RECEIVE = "weld:message:receive",
+    TYPING_START = "weld:typing:start",
+    TYPING_STOP = "weld:typing:stop",
+    BADGE_UPDATE = "weld:badge:update",
+    BADGE_CLEAR = "weld:badge:clear",
+    MOBILE_SCROLL_LOCK = "weld:mobile:scroll:lock",
+    MOBILE_SCROLL_UNLOCK = "weld:mobile:scroll:unlock",
+    CONFIG_UPDATE = "weld:config:update",
+    THEME_UPDATE = "weld:theme:update",
+    LOCALE_UPDATE = "weld:locale:update",
+    AUTH_LOGIN = "weld:auth:login",
+    AUTH_LOGOUT = "weld:auth:logout",
+    AUTH_TOKEN_UPDATE = "weld:auth:token:update",
+    EVENT_TRACK = "weld:event:track",
+    ERROR_REPORT = "weld:error:report",
+    API_SUCCESS = "weld:api:success",
+    API_ERROR = "weld:api:error"
+}
+/**
+ * Base message structure
+ */
+interface BaseMessage {
+    type: MessageType;
+    origin: MessageOrigin;
+    timestamp: number;
+    id: string;
+}
+/**
+ * Message with payload
+ */
+interface PayloadMessage<T = any> extends BaseMessage {
+    payload: T;
+}
+/**
+ * State update payload
+ */
+interface StateUpdatePayload {
+    path: string;
+    value: any;
+    merge?: boolean;
+}
+/**
+ * Widget state payload
+ */
+interface WidgetStatePayload {
+    isOpen: boolean;
+    isMinimized: boolean;
+    view?: string;
+    data?: any;
+}
+/**
+ * Launcher state payload
+ */
+interface LauncherStatePayload {
+    isVisible: boolean;
+    badgeCount?: number;
+    badgeText?: string;
+    customColor?: string;
+}
+/**
+ * Backdrop state payload
+ */
+interface BackdropStatePayload {
+    isVisible: boolean;
+    onClick?: 'close' | 'ignore';
+}
+/**
+ * Message data payload
+ */
+interface MessageDataPayload {
+    id: string;
+    text: string;
+    sender: 'user' | 'agent' | 'bot';
+    timestamp: number;
+    attachments?: Array<{
+        type: string;
+        url: string;
+        name?: string;
+    }>;
+}
+/**
+ * Configuration update payload
+ */
+interface ConfigUpdatePayload {
+    apiKey?: string;
+    workspaceId?: string;
+    position?: {
+        launcher?: {
+            bottom: string;
+            right: string;
+        };
+        widget?: {
+            bottom: string;
+            right: string;
+        };
+    };
+    customization?: {
+        primaryColor?: string;
+        accentColor?: string;
+        fontFamily?: string;
+    };
+    features?: {
+        attachments?: boolean;
+        reactions?: boolean;
+        typing?: boolean;
+    };
+}
+/**
+ * Theme update payload
+ */
+interface ThemeUpdatePayload {
+    mode: 'light' | 'dark' | 'auto';
+    primaryColor?: string;
+    accentColor?: string;
+    customCSS?: string;
+}
+/**
+ * Authentication payload
+ */
+interface AuthPayload {
+    userId?: string;
+    email?: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+    token?: string;
+}
+/**
+ * Error payload
+ */
+interface ErrorPayload {
+    code: string;
+    message: string;
+    stack?: string;
+    context?: Record<string, any>;
+}
+/**
+ * Event tracking payload
+ */
+interface EventPayload {
+    name: string;
+    properties?: Record<string, any>;
+    timestamp: number;
+}
+/**
+ * Type guards
+ */
+declare function isBaseMessage(message: any): message is BaseMessage;
+declare function isPayloadMessage<T = any>(message: any): message is PayloadMessage<T>;
+/**
+ * Message creator utilities
+ */
+declare function createMessage(type: MessageType, origin: MessageOrigin, payload?: any): PayloadMessage;
+/**
+ * Specific message type definitions
+ */
+type ReadyMessage = PayloadMessage<{
+    iframe: string;
+    ready: true;
+}>;
+type StateUpdateMessage = PayloadMessage<StateUpdatePayload>;
+type WidgetStateMessage = PayloadMessage<WidgetStatePayload>;
+type LauncherStateMessage = PayloadMessage<LauncherStatePayload>;
+type BackdropStateMessage = PayloadMessage<BackdropStatePayload>;
+type MessageDataMessage = PayloadMessage<MessageDataPayload>;
+type ConfigUpdateMessage = PayloadMessage<ConfigUpdatePayload>;
+type ThemeUpdateMessage = PayloadMessage<ThemeUpdatePayload>;
+type AuthMessage = PayloadMessage<AuthPayload>;
+type ErrorMessage = PayloadMessage<ErrorPayload>;
+type EventMessage = PayloadMessage<EventPayload>;
+/**
+ * Union type for all messages
+ */
+type WeldMessage = BaseMessage | ReadyMessage | StateUpdateMessage | WidgetStateMessage | LauncherStateMessage | BackdropStateMessage | MessageDataMessage | ConfigUpdateMessage | ThemeUpdateMessage | AuthMessage | ErrorMessage | EventMessage;
+
+/**
+ * Weld SDK - Logger Utility
+ * Centralized logging with configurable levels and formatting
+ */
+
+/**
+ * Log levels
+ */
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+/**
+ * Logger class
+ */
+declare class Logger {
+    private config;
+    private level;
+    constructor(config: LogConfig);
+    /**
+     * Convert string level to LogLevel enum
+     */
+    private getLevelFromString;
+    /**
+     * Check if logging is enabled for level
+     */
+    private shouldLog;
+    /**
+     * Format log message
+     */
+    private format;
+    /**
+     * Log debug message
+     */
+    debug(message: string, data?: any): void;
+    /**
+     * Log info message
+     */
+    info(message: string, data?: any): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string, data?: any): void;
+    /**
+     * Log error message
+     */
+    error(message: string, error?: Error | any): void;
+    /**
+     * Create child logger with prefix
+     */
+    child(prefix: string): Logger;
+    /**
+     * Update log level at runtime
+     */
+    setLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
+    /**
+     * Enable/disable logging
+     */
+    setEnabled(enabled: boolean): void;
+}
+/**
+ * Default logger instance
+ */
+declare const defaultLogger: Logger;
+
+/**
+ * Weld SDK - Message Broker
+ * Handles secure postMessage communication between parent and iframes
+ */
+
+/**
+ * Message handler callback
+ */
+type MessageHandler<T = any> = (payload: T, message: PayloadMessage<T>) => void;
+/**
+ * MessageBroker class
+ * Central hub for all postMessage communication
+ */
+declare class MessageBroker {
+    private config;
+    private logger;
+    private security;
+    private iframeManager;
+    private subscriptions;
+    private messageQueue;
+    private isReady;
+    private rateLimiter;
+    private responseHandlers;
+    constructor(config: ResolvedConfig, iframeManager: IframeManager, logger: Logger);
+    /**
+     * Setup global message listener
+     */
+    private setupMessageListener;
+    /**
+     * Handle incoming postMessage
+     */
+    private handleMessage;
+    /**
+     * Dispatch message to subscribers
+     */
+    private dispatchMessage;
+    /**
+     * Subscribe to messages
+     */
+    subscribe<T = any>(type: MessageType | '*', handler: MessageHandler<T>, origin?: MessageOrigin): string;
+    /**
+     * Unsubscribe from messages
+     */
+    unsubscribe(subscriptionId: string): void;
+    /**
+     * Send message to iframe
+     */
+    sendToIframe(iframeType: IframeType, type: MessageType, payload?: any): void;
+    /**
+     * Send message to all iframes
+     */
+    broadcast(type: MessageType, payload?: any): void;
+    /**
+     * Send message and wait for response
+     */
+    sendAndWaitForResponse<T = any>(iframeType: IframeType, type: MessageType, payload?: any, timeout?: number): Promise<T>;
+    /**
+     * Post message to iframe
+     */
+    private postMessage;
+    /**
+     * Mark iframe as ready and flush queued messages
+     */
+    setIframeReady(iframeType: IframeType): void;
+    /**
+     * Flush queued messages to iframe
+     */
+    private flushMessageQueue;
+    /**
+     * Check if broker is ready
+     */
+    isMessageBrokerReady(): boolean;
+    /**
+     * Get queued message count
+     */
+    getQueuedMessageCount(): number;
+    /**
+     * Clear message queue
+     */
+    clearMessageQueue(): void;
+    /**
+     * Get active subscription count
+     */
+    getSubscriptionCount(): number;
+    /**
+     * Destroy broker and cleanup
+     */
+    destroy(): void;
+}
+
+/**
+ * Weld SDK - State Coordinator
+ * Manages and synchronizes state across iframes
+ */
+
+/**
+ * StateCoordinator class
+ * Central state management for multi-iframe architecture
+ */
+declare class StateCoordinator {
+    private state;
+    private logger;
+    private messageBroker;
+    private subscriptions;
+    private stateHistory;
+    private maxHistorySize;
+    constructor(messageBroker: MessageBroker, logger: Logger);
+    /**
+     * Setup message handlers for state updates
+     */
+    private setupMessageHandlers;
+    /**
+     * Handle state update from iframe
+     */
+    private handleStateUpdate;
+    /**
+     * Handle state request from iframe
+     */
+    private handleStateRequest;
+    /**
+     * Get current state
+     */
+    getState(): WeldState;
+    /**
+     * Get state value by path
+     */
+    getValue<T = any>(path: string): T;
+    /**
+     * Update state
+     */
+    updateState(path: string, value: any, merge?: boolean): void;
+    /**
+     * Batch update multiple state paths
+     */
+    batchUpdate(updates: Array<{
+        path: string;
+        value: any;
+        merge?: boolean;
+    }>): void;
+    /**
+     * Reset state to initial
+     */
+    resetState(): void;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe<T = any>(path: string, listener: StateListener<T>, immediate?: boolean): string;
+    /**
+     * Unsubscribe from state changes
+     */
+    unsubscribe(subscriptionId: string): void;
+    /**
+     * Notify subscribers of state change
+     */
+    private notifySubscribers;
+    /**
+     * Add action to history
+     */
+    private addToHistory;
+    /**
+     * Get state history
+     */
+    getHistory(): StateAction[];
+    /**
+     * Clear state history
+     */
+    clearHistory(): void;
+    /**
+     * Get snapshot of state at specific time
+     */
+    getSnapshot(timestamp: number): WeldState | null;
+    /**
+     * Widget-specific state helpers
+     */
+    openWidget(): void;
+    closeWidget(): void;
+    minimizeWidget(): void;
+    maximizeWidget(): void;
+    setBadgeCount(count: number): void;
+    setUserAuth(userId: string, email?: string, name?: string): void;
+    setConnectionStatus(status: string): void;
+    setLoading(isLoading: boolean): void;
+    setError(code: string, message: string, recoverable?: boolean): void;
+    clearError(): void;
+    /**
+     * Get active subscription count
+     */
+    getSubscriptionCount(): number;
+    /**
+     * Validate state integrity
+     */
+    validateState(): boolean;
+    /**
+     * Export state as JSON
+     */
+    exportState(): string;
+    /**
+     * Import state from JSON
+     */
+    importState(json: string): boolean;
+    /**
+     * Destroy coordinator and cleanup
+     */
+    destroy(): void;
+}
+
+/**
+ * Weld SDK - Security Utilities
+ * Security validation and origin checking for postMessage communication
+ */
+
+/**
+ * SecurityManager class
+ */
+declare class SecurityManager {
+    private config;
+    private logger;
+    private allowedOrigins;
+    constructor(config: SecurityConfig, logger: Logger);
+    /**
+     * Validate message origin
+     */
+    isOriginAllowed(origin: string): boolean;
+    /**
+     * Match origin against pattern (supports wildcards)
+     */
+    private matchesPattern;
+    /**
+     * Validate postMessage event
+     */
+    validateMessageEvent(event: MessageEvent): boolean;
+    /**
+     * Sanitize message data
+     */
+    sanitizeMessageData(data: any): any;
+    /**
+     * Recursively sanitize object properties
+     */
+    private sanitizeObject;
+    /**
+     * Sanitize string to prevent XSS
+     */
+    private sanitizeString;
+    /**
+     * Generate secure random ID
+     */
+    generateSecureId(): string;
+    /**
+     * Validate iframe source
+     */
+    isValidIframeSource(src: string): boolean;
+    /**
+     * Create Content Security Policy
+     */
+    createCSP(): string;
+    /**
+     * Add allowed origin
+     */
+    addAllowedOrigin(origin: string): void;
+    /**
+     * Remove allowed origin
+     */
+    removeAllowedOrigin(origin: string): void;
+    /**
+     * Get all allowed origins
+     */
+    getAllowedOrigins(): string[];
+}
+/**
+ * Rate limiting utility
+ */
+declare class RateLimiter {
+    private requests;
+    private maxRequests;
+    private windowMs;
+    constructor(maxRequests?: number, windowMs?: number);
+    /**
+     * Check if request is allowed
+     */
+    isAllowed(key: string): boolean;
+    /**
+     * Reset rate limit for key
+     */
+    reset(key: string): void;
+    /**
+     * Clear all rate limits
+     */
+    clearAll(): void;
+}
+/**
+ * Token validation utilities
+ */
+declare class TokenValidator {
+    private static readonly TOKEN_PATTERN;
+    /**
+     * Check if string looks like a JWT token
+     */
+    static isJWT(token: string): boolean;
+    /**
+     * Decode JWT payload (without verification)
+     */
+    static decodeJWT(token: string): any | null;
+    /**
+     * Check if JWT is expired
+     */
+    static isExpired(token: string): boolean;
+}
+
+/**
+ * Weld SDK - Validation Utilities
+ * Input validation and sanitization functions
+ */
+/**
+ * Validate email format
+ */
+declare function isValidEmail(email: string): boolean;
+/**
+ * Validate URL format
+ */
+declare function isValidUrl(url: string): boolean;
+/**
+ * Validate API key format
+ */
+declare function isValidApiKey(apiKey: string): boolean;
+/**
+ * Validate workspace ID format
+ */
+declare function isValidWorkspaceId(workspaceId: string): boolean;
+/**
+ * Validate color format (hex, rgb, rgba)
+ */
+declare function isValidColor(color: string): boolean;
+/**
+ * Validate message text
+ */
+declare function isValidMessageText(text: string): boolean;
+/**
+ * Sanitize HTML to prevent XSS
+ */
+declare function sanitizeHtml(html: string): string;
+/**
+ * Sanitize user input
+ */
+declare function sanitizeInput(input: string): string;
+/**
+ * Validate object has required properties
+ */
+declare function hasRequiredProperties<T extends Record<string, any>>(obj: any, properties: (keyof T)[]): obj is T;
+/**
+ * Validate string length
+ */
+declare function isValidLength(str: string, options: {
+    min?: number;
+    max?: number;
+}): boolean;
+/**
+ * Validate number range
+ */
+declare function isInRange(num: number, options: {
+    min?: number;
+    max?: number;
+}): boolean;
+/**
+ * Validate array length
+ */
+declare function isValidArrayLength<T>(arr: T[], options: {
+    min?: number;
+    max?: number;
+}): boolean;
+/**
+ * Deep clone object (safe for JSON-serializable objects)
+ */
+declare function deepClone<T>(obj: T): T;
+/**
+ * Check if value is a plain object
+ */
+declare function isPlainObject(value: any): value is Record<string, any>;
+/**
+ * Merge objects deeply
+ */
+declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Validate file type
+ */
+declare function isValidFileType(file: File, allowedTypes: string[]): boolean;
+/**
+ * Validate file size
+ */
+declare function isValidFileSize(file: File, maxSizeBytes: number): boolean;
+/**
+ * Format file size for display
+ */
+declare function formatFileSize(bytes: number): string;
+
+export { ConnectionStatus, DEFAULT_CONFIG, WeldSDK as HelpdeskWidget, IframeManager, IframeType, LogLevel, Logger, MessageBroker, MessageOrigin, MessageStatus, MessageType, RateLimiter, SecurityManager, StateCoordinator, TokenValidator, WeldSDK, WidgetView, WidgetVisibility, createInitialState, createMessage, createWeldSDK, deepClone, deepMerge, WeldSDK as default, defaultLogger, formatFileSize, getStateValue, hasRequiredProperties, createWeldSDK as initHelpdeskWidget, isBaseMessage, isInRange, isPayloadMessage, isPlainObject, isValidApiKey, isValidArrayLength, isValidColor, isValidEmail, isValidFileSize, isValidFileType, isValidLength, isValidMessageText, isValidUrl, isValidWorkspaceId, resolveConfig, sanitizeHtml, sanitizeInput, setStateValue, validateConfig };
+export type { ApiConfig, Attachment, AuthConfig, AuthPayload, BackdropState, BackdropStatePayload, BaseMessage, ConfigUpdatePayload, ConversationState, CustomizationConfig, DeviceInfo, DeviceType, ErrorPayload, EventPayload, FeatureConfig, WeldConfig as HelpdeskWidgetConfig, IframeConfig, LauncherState, LauncherStatePayload, LocaleConfig, LogConfig, Message, MessageDataPayload, MobileConfig, MobileState, NetworkState, Participant, PayloadMessage, PerformanceConfig, PositionConfig, Reaction, ResolvedConfig, SecurityConfig, StateAction, StateListener, StateSubscription, StateUpdatePayload, ThemeUpdatePayload, UIState, UserState, WeldConfig, WeldMessage, WeldState, WidgetEvent, WidgetEventHandler, WidgetEventType, WidgetState, WidgetStatePayload };