@cloudsignal/pwa-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1197 @@
+/**
+ * CloudSignal PWA SDK Device Types
+ * Comprehensive device and platform detection types
+ */
+/**
+ * Complete device information (35+ fields)
+ */
+interface DeviceInfo {
+    /** Operating system name: iOS, Android, Windows, macOS, Linux */
+    os: string;
+    /** OS version (e.g., "17.2", "14.0", "Windows 10/11") */
+    osVersion: string;
+    /** Device type: iPhone, iPad, Phone, Tablet, Desktop */
+    deviceType: string;
+    /** Specific device model (e.g., "iPhone 15 Pro", "Samsung Galaxy S23") */
+    deviceModel: string;
+    /** Whether device is mobile */
+    isMobile: boolean;
+    /** Whether device is tablet */
+    isTablet: boolean;
+    /** Whether device is desktop */
+    isDesktop: boolean;
+    /** Whether running in WebView (Facebook, Instagram, etc.) */
+    isWebView: boolean;
+    /** Browser name: Chrome, Safari, Firefox, Edge, Samsung Internet */
+    browser: string;
+    /** Browser version number */
+    browserVersion: string;
+    /** iOS device detected */
+    isIOS: boolean;
+    /** Android device detected */
+    isAndroid: boolean;
+    /** macOS device detected */
+    isMacOS: boolean;
+    /** Windows device detected */
+    isWindows: boolean;
+    /** Linux device detected */
+    isLinux: boolean;
+    /** Screen width in pixels */
+    screenWidth: number;
+    /** Screen height in pixels */
+    screenHeight: number;
+    /** Device pixel ratio (1-3) */
+    pixelRatio: number;
+    /** PWA support level: "full", "partial", "basic", "none" */
+    supportLevel: PWASupportLevel;
+    /** Whether Notification API is available */
+    hasNotificationPermission: boolean;
+    /** Whether Push Manager is supported */
+    hasPushManager: boolean;
+    /** Whether service workers are supported */
+    hasServiceWorker: boolean;
+    /** Whether Web Share API is available */
+    hasShareAPI: boolean;
+    /** Whether Badge API is available */
+    hasBadgeAPI: boolean;
+    /** Notification permission: "granted", "denied", "default" */
+    notificationPermission: NotificationPermissionState;
+    /** Current online/offline status */
+    isOnline: boolean;
+    /** Connection type: "4g", "3g", "2g", "slow-2g", "unknown" */
+    connectionType: string;
+    /** Platform emoji icon: 📱, 🤖, 💻, 🖥️ */
+    platformIcon: string;
+    /** Full user agent string for debugging */
+    userAgent: string;
+    /** Unique tracking ID combining device info */
+    trackingId: string;
+    /** Browser fingerprint (if generated) */
+    browserFingerprint?: string;
+}
+/**
+ * PWA support level
+ */
+type PWASupportLevel = 'full' | 'partial' | 'basic' | 'none';
+/**
+ * Notification permission state
+ */
+type NotificationPermissionState = 'granted' | 'denied' | 'default';
+/**
+ * PWA installation state
+ */
+interface InstallationState {
+    /** Whether PWA is currently installed */
+    isInstalled: boolean;
+    /** Whether browser can show install prompt */
+    canBeInstalled: boolean;
+    /** Whether manual installation is needed (iOS Safari) */
+    needsManualInstall: boolean;
+    /** Whether to show manual installation instructions */
+    showManualInstructions: boolean;
+    /** Installation steps for current platform */
+    installSteps: string[];
+    /** Display mode: 'browser' | 'standalone' | 'minimal-ui' | 'fullscreen' */
+    displayMode: DisplayMode;
+}
+/**
+ * Display mode for PWA
+ */
+type DisplayMode = 'browser' | 'standalone' | 'minimal-ui' | 'fullscreen';
+/**
+ * Install prompt result
+ */
+interface InstallResult {
+    /** Whether installation was accepted */
+    accepted: boolean;
+    /** User's choice: 'accepted' | 'dismissed' */
+    outcome: 'accepted' | 'dismissed';
+    /** Platform that was installed on */
+    platform?: string;
+}
+/**
+ * Platform-specific information
+ */
+interface PlatformInfo {
+    os: string;
+    osVersion: string;
+    browser: string;
+    browserVersion: string;
+    deviceType: string;
+    deviceModel: string;
+    isWebView: boolean;
+    userAgent: string;
+}
+/**
+ * Screen information
+ */
+interface ScreenInfo {
+    width: number;
+    height: number;
+    pixelRatio: number;
+    orientation: 'portrait' | 'landscape';
+}
+/**
+ * Network information
+ */
+interface NetworkInfo {
+    isOnline: boolean;
+    connectionType: string;
+    effectiveType?: string;
+    downlink?: number;
+    rtt?: number;
+    saveData?: boolean;
+}
+/**
+ * PWA capabilities detection result
+ */
+interface PWACapabilities {
+    /** Service Worker API available */
+    serviceWorker: boolean;
+    /** Push API available */
+    push: boolean;
+    /** Notification API available */
+    notifications: boolean;
+    /** Background Sync API available */
+    backgroundSync: boolean;
+    /** Badge API available */
+    badge: boolean;
+    /** Web Share API available */
+    share: boolean;
+    /** Share Target API available */
+    shareTarget: boolean;
+    /** File System Access API available */
+    fileSystemAccess: boolean;
+    /** Contact Picker API available */
+    contactPicker: boolean;
+    /** Periodic Background Sync available */
+    periodicSync: boolean;
+    /** Overall support level */
+    supportLevel: PWASupportLevel;
+}
+/**
+ * BeforeInstallPrompt event interface
+ */
+interface BeforeInstallPromptEvent extends Event {
+    /** Platforms the PWA can be installed on */
+    platforms: string[];
+    /** Promise that resolves with user choice */
+    userChoice: Promise<{
+        outcome: 'accepted' | 'dismissed';
+        platform: string;
+    }>;
+    /** Show the install prompt */
+    prompt(): Promise<void>;
+}
+
+/**
+ * CloudSignal PWA SDK Configuration Types
+ */
+/**
+ * Main SDK configuration options
+ */
+interface PWAConfig {
+    /** CloudSignal PWA service URL */
+    serviceUrl?: string;
+    /** Organization ID (UUID) */
+    organizationId: string;
+    /** Organization secret key for HMAC authentication */
+    organizationSecret: string;
+    /** PWA service ID (UUID) */
+    serviceId: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Platform preset for optimized settings */
+    preset?: 'mobile' | 'desktop' | 'auto';
+    /** Service worker configuration */
+    serviceWorker?: ServiceWorkerConfig;
+    /** Heartbeat configuration */
+    heartbeat?: HeartbeatConfig;
+    /** Custom logger function */
+    logger?: LoggerFunction;
+}
+/**
+ * Service worker configuration
+ */
+interface ServiceWorkerConfig {
+    /** Path to service worker file */
+    path?: string;
+    /** Service worker scope */
+    scope?: string;
+    /** Auto-register service worker on initialization */
+    autoRegister?: boolean;
+    /** Update behavior: 'prompt' | 'auto' | 'manual' */
+    updateBehavior?: 'prompt' | 'auto' | 'manual';
+}
+/**
+ * Heartbeat configuration for online status tracking
+ */
+interface HeartbeatConfig {
+    /** Enable heartbeat */
+    enabled?: boolean;
+    /** Heartbeat interval in milliseconds (default: 30000) */
+    interval?: number;
+    /** Automatically start heartbeat when registered */
+    autoStart?: boolean;
+    /** Stop heartbeat when page is hidden */
+    stopOnHidden?: boolean;
+}
+/**
+ * Logger function signature
+ */
+type LoggerFunction = (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: any) => void;
+/**
+ * PWA service configuration returned from backend
+ */
+interface PWAServiceConfig {
+    /** Service identifier */
+    service_identifier: string;
+    /** Service name for display */
+    service_name: string;
+    /** VAPID public key for push subscriptions */
+    vapid_public_key: string;
+    /** Whether notifications are enabled */
+    notifications_enabled: boolean;
+    /** Service ID (UUID) */
+    service_id?: string;
+    /** Icon URL */
+    icon_url?: string;
+    /** Manifest URL */
+    manifest_url?: string;
+}
+/**
+ * Options for registering push notifications
+ */
+interface RegisterOptions {
+    /** User email address */
+    userEmail?: string;
+    /** User ID (UUID) */
+    userId?: string;
+    /** Notification topics to subscribe to */
+    topics?: string[];
+    /** User's timezone */
+    timezone?: string;
+    /** User's preferred language */
+    language?: string;
+}
+/**
+ * Options for updating notification preferences
+ */
+interface NotificationPreferences {
+    /** Topics to subscribe to */
+    topics?: string[];
+    /** Timezone */
+    timezone?: string;
+    /** Language */
+    language?: string;
+    /** Whether registration is active */
+    isActive?: boolean;
+}
+/**
+ * SDK initialization result
+ */
+interface InitializeResult {
+    /** Whether initialization was successful */
+    success: boolean;
+    /** Service configuration if loaded */
+    config?: PWAServiceConfig;
+    /** Device information */
+    deviceInfo?: DeviceInfo;
+    /** Installation state */
+    installationState?: InstallationState;
+    /** Error message if failed */
+    error?: string;
+}
+
+/**
+ * CloudSignal PWA SDK Notification Types
+ */
+/**
+ * Push notification registration response
+ */
+interface Registration {
+    /** Registration ID (UUID) */
+    registrationId: string;
+    /** Registration status */
+    status: RegistrationStatus;
+    /** When registration was created */
+    createdAt: string;
+    /** Whether registration is active */
+    isActive: boolean;
+}
+/**
+ * Registration status
+ */
+type RegistrationStatus = 'active' | 'inactive' | 'expired' | 'unregistered';
+/**
+ * Registration status response from backend
+ */
+interface RegistrationStatusResponse {
+    /** Registration ID */
+    registrationId: string;
+    /** Current status */
+    status: RegistrationStatus;
+    /** Whether registration is active */
+    isActive: boolean;
+    /** Whether client is currently online */
+    isOnline: boolean;
+    /** Last activity timestamp */
+    lastActive: string;
+    /** Last seen online timestamp */
+    lastSeenOnline?: string;
+    /** Last heartbeat timestamp */
+    lastHeartbeat?: string;
+    /** When PWA was first installed */
+    installationDate?: string;
+    /** Total notifications sent to this registration */
+    notificationCount: number;
+    /** Device information */
+    deviceInfo: {
+        deviceType: string;
+        browser: string;
+        os: string;
+    };
+}
+/**
+ * Push subscription data sent to backend
+ */
+interface PushSubscriptionData {
+    /** Service ID (UUID) */
+    serviceId: string;
+    /** User email (optional) */
+    userEmail?: string;
+    /** User ID (UUID, optional) */
+    userId?: string;
+    /** Push endpoint URL */
+    endpoint: string;
+    /** Push encryption keys */
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+    /** Browser fingerprint for deduplication */
+    browserFingerprint?: string;
+    /** Device type */
+    deviceType: string;
+    /** Device model */
+    deviceModel?: string;
+    /** Browser name */
+    browserName: string;
+    /** Browser version */
+    browserVersion?: string;
+    /** OS name */
+    osName: string;
+    /** OS version */
+    osVersion?: string;
+    /** Full user agent */
+    userAgent: string;
+    /** Display mode */
+    displayMode?: string;
+    /** Whether PWA is installed */
+    isInstalled?: boolean;
+    /** User's timezone */
+    timezone?: string;
+    /** User's language */
+    language?: string;
+}
+/**
+ * Notification payload structure
+ */
+interface NotificationPayload {
+    /** Notification title */
+    title: string;
+    /** Notification body text */
+    body: string;
+    /** Icon URL */
+    icon?: string;
+    /** Badge icon URL */
+    badge?: string;
+    /** Large image URL */
+    image?: string;
+    /** Notification tag for grouping */
+    tag?: string;
+    /** Whether notification requires interaction */
+    requireInteraction?: boolean;
+    /** Custom data payload */
+    data?: Record<string, any>;
+    /** URL to open on click */
+    url?: string;
+    /** Notification actions/buttons */
+    actions?: NotificationAction[];
+    /** Vibration pattern */
+    vibrate?: number[];
+    /** Whether to renotify for same tag */
+    renotify?: boolean;
+    /** Whether notification is silent */
+    silent?: boolean;
+    /** Timestamp */
+    timestamp?: number;
+}
+/**
+ * Notification action button
+ */
+interface NotificationAction {
+    /** Action identifier */
+    action: string;
+    /** Action button title */
+    title: string;
+    /** Action icon URL */
+    icon?: string;
+}
+/**
+ * Event types emitted by the SDK
+ */
+type PWAEvent = 'install:available' | 'install:accepted' | 'install:dismissed' | 'install:completed' | 'install:error' | 'push:registered' | 'push:unregistered' | 'push:updated' | 'push:error' | 'push:received' | 'push:clicked' | 'permission:granted' | 'permission:denied' | 'permission:prompt' | 'sw:registered' | 'sw:updated' | 'sw:error' | 'sw:activated' | 'config:loaded' | 'config:error' | 'heartbeat:started' | 'heartbeat:stopped' | 'heartbeat:sent' | 'heartbeat:error' | 'network:online' | 'network:offline' | 'state:changed';
+/**
+ * Event handler function
+ */
+type EventHandler<T = any> = (data: T) => void;
+/**
+ * Event data for install:available
+ */
+interface InstallAvailableEvent {
+    platforms: string[];
+}
+/**
+ * Event data for install:accepted/dismissed
+ */
+interface InstallResultEvent {
+    outcome: 'accepted' | 'dismissed';
+    platform?: string;
+}
+/**
+ * Event data for push:registered
+ */
+interface PushRegisteredEvent {
+    registrationId: string;
+    endpoint: string;
+}
+/**
+ * Event data for push:received
+ */
+interface PushReceivedEvent {
+    payload: NotificationPayload;
+    timestamp: number;
+}
+/**
+ * Event data for push:clicked
+ */
+interface PushClickedEvent {
+    action?: string;
+    data?: Record<string, any>;
+    url?: string;
+}
+/**
+ * Event data for permission changes
+ */
+interface PermissionEvent {
+    permission: 'granted' | 'denied' | 'default';
+    previousPermission?: 'granted' | 'denied' | 'default';
+}
+/**
+ * Event data for service worker events
+ */
+interface ServiceWorkerEvent {
+    registration?: ServiceWorkerRegistration;
+    error?: Error;
+}
+/**
+ * Event data for config:loaded
+ */
+interface ConfigLoadedEvent {
+    config: PWAServiceConfig;
+}
+/**
+ * Event data for heartbeat events
+ */
+interface HeartbeatEvent {
+    registrationId?: string;
+    timestamp: number;
+    error?: string;
+}
+/**
+ * Event data for network events
+ */
+interface NetworkEvent {
+    isOnline: boolean;
+    connectionType?: string;
+}
+
+/**
+ * CloudSignal PWA Client
+ * Main class for PWA functionality including installation, push notifications, and device tracking
+ */
+declare class CloudSignalPWA {
+    private config;
+    private serviceUrl;
+    private debug;
+    private initialized;
+    private serviceConfig;
+    private deviceDetector;
+    private serviceWorkerManager;
+    private installationManager;
+    private pushNotificationManager;
+    private heartbeatManager;
+    private eventHandlers;
+    constructor(config: PWAConfig);
+    /**
+     * Initialize the PWA client
+     * Downloads config, registers service worker, and sets up event listeners
+     */
+    initialize(): Promise<InitializeResult>;
+    /**
+     * Download PWA service configuration from backend
+     */
+    downloadConfig(): Promise<PWAServiceConfig | null>;
+    /**
+     * Show the PWA install prompt
+     */
+    showInstallPrompt(): Promise<InstallResult>;
+    /**
+     * Get current installation state
+     */
+    getInstallationState(): InstallationState;
+    /**
+     * Check if PWA can be installed
+     */
+    canInstall(): boolean;
+    /**
+     * Check if PWA is installed
+     */
+    isInstalled(): boolean;
+    /**
+     * Get installation steps for current platform
+     */
+    getInstallSteps(): string[];
+    /**
+     * Register for push notifications
+     */
+    registerForPush(options?: RegisterOptions): Promise<Registration | null>;
+    /**
+     * Unregister from push notifications
+     */
+    unregisterFromPush(): Promise<boolean>;
+    /**
+     * Update notification preferences
+     */
+    updatePreferences(preferences: NotificationPreferences): Promise<boolean>;
+    /**
+     * Check registration status
+     */
+    checkRegistrationStatus(): Promise<RegistrationStatusResponse | null>;
+    /**
+     * Get current registration ID
+     */
+    getRegistrationId(): string | null;
+    /**
+     * Check if registered for push notifications
+     */
+    isRegistered(): boolean;
+    /**
+     * Request notification permission
+     */
+    requestPermission(): Promise<NotificationPermission>;
+    /**
+     * Get comprehensive device information
+     */
+    getDeviceInfo(): DeviceInfo;
+    /**
+     * Get PWA capabilities
+     */
+    getCapabilities(): PWACapabilities;
+    /**
+     * Start heartbeat for online status tracking
+     */
+    startHeartbeat(): void;
+    /**
+     * Stop heartbeat
+     */
+    stopHeartbeat(): void;
+    /**
+     * Clear app badge
+     */
+    clearBadge(): void;
+    /**
+     * Set app badge count
+     */
+    setBadge(count: number): void;
+    /**
+     * Check for service worker updates
+     */
+    checkForUpdates(): Promise<void>;
+    /**
+     * Subscribe to an event
+     */
+    on(event: PWAEvent, handler: EventHandler): void;
+    /**
+     * Unsubscribe from an event
+     */
+    off(event: PWAEvent, handler: EventHandler): void;
+    /**
+     * Emit an event
+     */
+    private emit;
+    /**
+     * Get SDK version
+     */
+    getVersion(): string;
+    /**
+     * Get service configuration
+     */
+    getServiceConfig(): PWAServiceConfig | null;
+    /**
+     * Check if client is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Inject PWA manifest link
+     */
+    private injectManifest;
+    /**
+     * Set up network status listeners
+     */
+    private setupNetworkListeners;
+    /**
+     * Log message if debug is enabled
+     */
+    private log;
+}
+
+/**
+ * DeviceDetector - Comprehensive Platform and Device Detection
+ * Ported from bubble-pwa-complete-handler.js with TypeScript support
+ */
+
+/**
+ * DeviceDetector class for comprehensive device and platform detection
+ */
+declare class DeviceDetector {
+    private cachedInfo;
+    /**
+     * Get comprehensive device information
+     */
+    getDeviceInfo(): DeviceInfo;
+    /**
+     * Clear cached device info (useful when network/permissions change)
+     */
+    clearCache(): void;
+    /**
+     * Get platform-specific information
+     */
+    getPlatformInfo(): PlatformInfo;
+    /**
+     * Get screen information
+     */
+    getScreenInfo(): ScreenInfo;
+    /**
+     * Get network information
+     */
+    getNetworkInfo(): NetworkInfo;
+    /**
+     * Get PWA capabilities
+     */
+    getCapabilities(): PWACapabilities;
+    /**
+     * Get notification permission state
+     */
+    getNotificationPermission(): NotificationPermissionState;
+    /**
+     * Check if device is mobile
+     */
+    isMobile(): boolean;
+    /**
+     * Check if device is tablet
+     */
+    isTablet(): boolean;
+    /**
+     * Check if device is desktop
+     */
+    isDesktop(): boolean;
+    /**
+     * Get platform icon emoji
+     */
+    private getPlatformIcon;
+    /**
+     * Detect iPhone model from user agent
+     */
+    private detectiPhoneModel;
+    /**
+     * Detect iPad model from user agent
+     */
+    private detectiPadModel;
+    /**
+     * Detect Android device model
+     */
+    private detectAndroidDevice;
+    /**
+     * Get Windows version from NT version
+     */
+    private getWindowsVersion;
+    /**
+     * Detect if running in WebView
+     */
+    private detectWebView;
+}
+declare const deviceDetector: DeviceDetector;
+
+/**
+ * ServiceWorkerManager - Service Worker Registration and Management
+ */
+
+interface ServiceWorkerManagerOptions {
+    config?: ServiceWorkerConfig;
+    onRegistered?: (registration: ServiceWorkerRegistration) => void;
+    onUpdated?: (registration: ServiceWorkerRegistration) => void;
+    onError?: (error: Error) => void;
+    debug?: boolean;
+}
+/**
+ * ServiceWorkerManager handles service worker registration, updates, and communication
+ */
+declare class ServiceWorkerManager {
+    private registration;
+    private config;
+    private debug;
+    private onRegistered?;
+    private onUpdated?;
+    private onError?;
+    constructor(options?: ServiceWorkerManagerOptions);
+    /**
+     * Check if service workers are supported
+     */
+    isSupported(): boolean;
+    /**
+     * Get the current service worker registration
+     */
+    getRegistration(): ServiceWorkerRegistration | null;
+    /**
+     * Register the service worker
+     */
+    register(): Promise<ServiceWorkerRegistration | null>;
+    /**
+     * Unregister the service worker
+     */
+    unregister(): Promise<boolean>;
+    /**
+     * Check for service worker updates
+     */
+    checkForUpdate(): Promise<void>;
+    /**
+     * Wait for service worker to be ready
+     */
+    waitForReady(timeout?: number): Promise<ServiceWorkerRegistration | null>;
+    /**
+     * Send a message to the service worker
+     */
+    postMessage(message: any): void;
+    /**
+     * Clear app badge via service worker
+     */
+    clearBadge(): void;
+    /**
+     * Set app badge via service worker
+     */
+    setBadge(count: number): void;
+    /**
+     * Handle service worker update found
+     */
+    private handleUpdateFound;
+    /**
+     * Get service worker path and scope based on environment
+     * Handles Bubble.io version-live/version-test paths
+     */
+    private getPathAndScope;
+    /**
+     * Log message if debug is enabled
+     */
+    private log;
+}
+
+/**
+ * InstallationManager - PWA Installation Detection and Prompts
+ */
+
+interface InstallationManagerOptions {
+    onInstallAvailable?: (event: BeforeInstallPromptEvent) => void;
+    onInstallAccepted?: (result: InstallResult) => void;
+    onInstallDismissed?: (result: InstallResult) => void;
+    onInstalled?: () => void;
+    debug?: boolean;
+}
+/**
+ * InstallationManager handles PWA installation detection and prompts
+ */
+declare class InstallationManager {
+    private deferredPrompt;
+    private isInstalled;
+    private debug;
+    private onInstallAvailable?;
+    private onInstallAccepted?;
+    private onInstallDismissed?;
+    private onInstalled?;
+    constructor(options?: InstallationManagerOptions);
+    /**
+     * Initialize event listeners
+     */
+    initialize(): void;
+    /**
+     * Get current installation state
+     */
+    getState(): InstallationState;
+    /**
+     * Show the install prompt
+     */
+    showInstallPrompt(): Promise<InstallResult>;
+    /**
+     * Check if install prompt is available
+     */
+    canInstall(): boolean;
+    /**
+     * Check if PWA is installed
+     */
+    isPWAInstalled(): boolean;
+    /**
+     * Get current display mode
+     */
+    getDisplayMode(): DisplayMode;
+    /**
+     * Get installation steps for current platform
+     */
+    getInstallSteps(): string[];
+    /**
+     * Detect initial installation status
+     */
+    private detectInstallationStatus;
+    /**
+     * Check if device is iOS
+     */
+    private isIOSDevice;
+    /**
+     * Check if device is Android
+     */
+    private isAndroidDevice;
+    /**
+     * Check if browser is Safari
+     */
+    private isSafariBrowser;
+    /**
+     * Log message if debug is enabled
+     */
+    private log;
+}
+
+/**
+ * PushNotificationManager - Push Notification Registration and Management
+ */
+
+interface PushNotificationManagerOptions {
+    serviceUrl: string;
+    organizationId: string;
+    organizationSecret: string;
+    serviceId: string;
+    debug?: boolean;
+    onRegistered?: (registration: Registration) => void;
+    onUnregistered?: () => void;
+    onError?: (error: Error) => void;
+    onPermissionDenied?: () => void;
+}
+/**
+ * PushNotificationManager handles push notification registration with CloudSignal backend
+ */
+declare class PushNotificationManager {
+    private serviceUrl;
+    private organizationId;
+    private organizationSecret;
+    private serviceId;
+    private debug;
+    private deviceDetector;
+    private serviceWorkerRegistration;
+    private pushSubscription;
+    private registrationId;
+    private vapidPublicKey;
+    private onRegistered?;
+    private onUnregistered?;
+    private onError?;
+    private onPermissionDenied?;
+    constructor(options: PushNotificationManagerOptions);
+    /**
+     * Set service worker registration
+     */
+    setServiceWorkerRegistration(registration: ServiceWorkerRegistration): void;
+    /**
+     * Set VAPID public key from config
+     */
+    setVapidPublicKey(key: string): void;
+    /**
+     * Get current registration ID
+     */
+    getRegistrationId(): string | null;
+    /**
+     * Check if registered for push notifications
+     */
+    isRegistered(): boolean;
+    /**
+     * Register for push notifications
+     */
+    register(options?: RegisterOptions): Promise<Registration | null>;
+    /**
+     * Unregister from push notifications
+     */
+    unregister(): Promise<boolean>;
+    /**
+     * Update notification preferences
+     */
+    updatePreferences(preferences: NotificationPreferences): Promise<boolean>;
+    /**
+     * Check registration status
+     */
+    checkStatus(): Promise<RegistrationStatusResponse | null>;
+    /**
+     * Request notification permission
+     */
+    requestPermission(): Promise<NotificationPermission>;
+    /**
+     * Subscribe to push notifications
+     */
+    private subscribeToPush;
+    /**
+     * Convert base64 VAPID key to Uint8Array
+     */
+    private urlBase64ToUint8Array;
+    /**
+     * Log message if debug is enabled
+     */
+    private log;
+}
+
+/**
+ * HeartbeatManager - Online Status Tracking via Periodic Heartbeat
+ */
+
+interface HeartbeatManagerOptions {
+    serviceUrl: string;
+    organizationId: string;
+    organizationSecret: string;
+    config?: HeartbeatConfig;
+    debug?: boolean;
+    onHeartbeatSent?: () => void;
+    onHeartbeatError?: (error: Error) => void;
+}
+/**
+ * HeartbeatManager sends periodic heartbeats to track online status
+ */
+declare class HeartbeatManager {
+    private serviceUrl;
+    private organizationId;
+    private organizationSecret;
+    private config;
+    private debug;
+    private registrationId;
+    private intervalId;
+    private isRunning;
+    private visibilityHandler;
+    private onHeartbeatSent?;
+    private onHeartbeatError?;
+    constructor(options: HeartbeatManagerOptions);
+    /**
+     * Set the registration ID for heartbeat requests
+     */
+    setRegistrationId(registrationId: string): void;
+    /**
+     * Start sending heartbeats
+     */
+    start(): void;
+    /**
+     * Stop sending heartbeats
+     */
+    stop(): void;
+    /**
+     * Check if heartbeat is running
+     */
+    isHeartbeatRunning(): boolean;
+    /**
+     * Send a single heartbeat
+     */
+    sendHeartbeat(): Promise<boolean>;
+    /**
+     * Update heartbeat configuration
+     */
+    updateConfig(config: Partial<HeartbeatConfig>): void;
+    /**
+     * Set up visibility change handler
+     */
+    private setupVisibilityHandler;
+    /**
+     * Log message if debug is enabled
+     */
+    private log;
+}
+
+/**
+ * HMAC Authentication Utilities
+ * Implements CloudSignal's HMAC signature scheme for API authentication
+ */
+/**
+ * Generate HMAC signature for CloudSignal API requests
+ *
+ * @param secret - Organization secret key
+ * @param organizationId - Organization UUID
+ * @param timestamp - Unix timestamp string
+ * @param method - HTTP method (GET, POST, etc.)
+ * @param url - Full URL or path
+ * @param body - Request body (optional)
+ * @returns Base64-encoded HMAC signature
+ */
+declare function generateHMACSignature(secret: string, organizationId: string, timestamp: string, method: string, url: string, body?: string): Promise<string>;
+/**
+ * Generate authentication headers for CloudSignal API requests
+ *
+ * @param organizationId - Organization UUID
+ * @param organizationSecret - Organization secret key
+ * @param method - HTTP method
+ * @param url - Request URL
+ * @param body - Request body (optional)
+ * @returns Headers object with authentication headers
+ */
+declare function generateAuthHeaders(organizationId: string, organizationSecret: string, method: string, url: string, body?: string): Promise<Record<string, string>>;
+/**
+ * Make an authenticated request to CloudSignal API
+ *
+ * @param organizationId - Organization UUID
+ * @param organizationSecret - Organization secret key
+ * @param method - HTTP method
+ * @param url - Request URL
+ * @param body - Request body (optional)
+ * @returns Fetch Response
+ */
+declare function makeAuthenticatedRequest(organizationId: string, organizationSecret: string, method: string, url: string, body?: Record<string, any>): Promise<Response>;
+/**
+ * Validate UUID format
+ *
+ * @param value - String to validate
+ * @returns Whether the string is a valid UUID
+ */
+declare function isValidUUID(value: string | null | undefined): boolean;
+
+/**
+ * Browser Fingerprinting Utilities
+ * Generate unique device identifiers for registration deduplication
+ */
+/**
+ * Generate a browser fingerprint using multiple signals
+ * This is used to identify the same browser across sessions
+ *
+ * @returns Fingerprint string or null if generation fails
+ */
+declare function generateBrowserFingerprint(): Promise<string | null>;
+/**
+ * Generate a simple tracking ID from device info
+ * Less privacy-invasive than full fingerprinting
+ */
+declare function generateTrackingId(os: string, osVersion: string, browser: string, browserVersion: string, deviceModel: string): string;
+
+/**
+ * Storage Utilities
+ * LocalStorage and IndexedDB helpers with type safety
+ */
+/**
+ * Get item from localStorage with type safety
+ */
+declare function getStorageItem<T>(key: string, defaultValue?: T): T | null;
+/**
+ * Set item in localStorage
+ */
+declare function setStorageItem<T>(key: string, value: T): boolean;
+/**
+ * Remove item from localStorage
+ */
+declare function removeStorageItem(key: string): boolean;
+/**
+ * Get registration ID from storage
+ */
+declare function getRegistrationId(organizationId: string, serviceId: string): string | null;
+/**
+ * Set registration ID in storage
+ */
+declare function setRegistrationId(organizationId: string, serviceId: string, registrationId: string): boolean;
+/**
+ * Remove registration ID from storage
+ */
+declare function removeRegistrationId(organizationId: string, serviceId: string): boolean;
+/**
+ * IndexedDB Storage for Service Worker
+ * Provides persistent storage for badge counts, notifications, etc.
+ */
+declare class IndexedDBStorage {
+    private dbName;
+    private dbVersion;
+    private db;
+    constructor(dbName?: string, dbVersion?: number);
+    /**
+     * Initialize the database
+     */
+    init(): Promise<IDBDatabase>;
+    /**
+     * Ensure database connection
+     */
+    private ensureConnection;
+    /**
+     * Promisify IDBRequest
+     */
+    private promisifyRequest;
+    /**
+     * Get badge count
+     */
+    getBadgeCount(): Promise<number>;
+    /**
+     * Set badge count
+     */
+    setBadgeCount(count: number): Promise<void>;
+    /**
+     * Increment badge count
+     */
+    incrementBadgeCount(increment?: number): Promise<number>;
+    /**
+     * Save notification to history
+     */
+    saveNotification(notification: Record<string, any>): Promise<number>;
+    /**
+     * Get recent notifications
+     */
+    getRecentNotifications(limit?: number): Promise<any[]>;
+    /**
+     * Mark notification as read
+     */
+    markNotificationAsRead(notificationId: number): Promise<void>;
+    /**
+     * Get user preference
+     */
+    getUserPreference<T>(key: string): Promise<T | null>;
+    /**
+     * Set user preference
+     */
+    setUserPreference<T>(key: string, value: T): Promise<void>;
+    /**
+     * Add item to sync queue
+     */
+    addToSyncQueue(action: Record<string, any>): Promise<number>;
+    /**
+     * Get sync queue items
+     */
+    getSyncQueue(): Promise<any[]>;
+    /**
+     * Remove item from sync queue
+     */
+    removeFromSyncQueue(id: number): Promise<void>;
+}
+
+/**
+ * CloudSignal PWA SDK
+ * Progressive Web App features with push notifications, installation management, and device tracking
+ *
+ * @packageDocumentation
+ */
+
+declare const VERSION = "1.0.0";
+
+export { type BeforeInstallPromptEvent, CloudSignalPWA, type ConfigLoadedEvent, DeviceDetector, type DeviceInfo, type DisplayMode, type EventHandler, type HeartbeatConfig, type HeartbeatEvent, HeartbeatManager, IndexedDBStorage, type InitializeResult, type InstallAvailableEvent, type InstallResult, type InstallResultEvent, InstallationManager, type InstallationState, type LoggerFunction, type NetworkEvent, type NetworkInfo, type NotificationAction, type NotificationPayload, type NotificationPermissionState, type NotificationPreferences, type PWACapabilities, type PWAConfig, type PWAEvent, type PWAServiceConfig, type PWASupportLevel, type PermissionEvent, type PlatformInfo, type PushClickedEvent, PushNotificationManager, type PushReceivedEvent, type PushRegisteredEvent, type PushSubscriptionData, type RegisterOptions, type Registration, type RegistrationStatus, type RegistrationStatusResponse, type ScreenInfo, type ServiceWorkerConfig, type ServiceWorkerEvent, ServiceWorkerManager, VERSION, CloudSignalPWA as default, deviceDetector, generateAuthHeaders, generateBrowserFingerprint, generateHMACSignature, generateTrackingId, getRegistrationId, getStorageItem, isValidUUID, makeAuthenticatedRequest, removeRegistrationId, removeStorageItem, setRegistrationId, setStorageItem };