@insure-os/client 0.0.3

package/dist/index.d.ts

@@ -0,0 +1,1099 @@
+import { QuoteIntentResponse, CalculationResponse, PaymentInitiationRequest, PaymentGateway, FormDefinition, FormData, FormField, FormPage, PaymentOption, CalculationExcessOption } from '@insure-os/types';
+export { FieldValidation, FormData, FormDefinition, FormError, FormErrorType, FormField, FormPage, FormSettings, PageValidation, SelectOption } from '@insure-os/types';
+import * as Sentry from '@sentry/browser';
+
+interface RetryConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    retryableStatusCodes: number[];
+}
+interface HttpClientConfig {
+    orgId: string;
+    apiBaseUrl?: string;
+    timeout: number;
+    retryConfig: RetryConfig;
+}
+/**
+ * Enhanced HTTP client with retry logic and better error handling
+ */
+declare class EnhancedHttpClient {
+    private config;
+    private retryStrategy;
+    constructor(config: HttpClientConfig);
+    getBaseUrl(): string;
+    private makeRequest;
+    getQuoteIntent(url: string): Promise<QuoteIntentResponse>;
+    createQuoteIntent(body: any): Promise<QuoteIntentResponse>;
+    updateQuoteIntent(url: string, data: any): Promise<QuoteIntentResponse>;
+    deleteQuoteIntent(url: string): Promise<void>;
+    calculateQuoteIntent(url: string): Promise<CalculationResponse>;
+    initiatePayment(request: PaymentInitiationRequest, gateway: PaymentGateway): Promise<any>;
+    getPaymentStatus(transactionId: string, gateway: PaymentGateway): Promise<any>;
+    private executeWithRetry;
+    private handleApiError;
+    /**
+     * Capture API error to Sentry
+     */
+    private captureApiErrorToSentry;
+}
+
+interface PolyfillConfig {
+    fetch: boolean;
+    promise: boolean;
+    url: boolean;
+}
+interface FeatureDetectionResult {
+    fetch: boolean;
+    promise: boolean;
+    url: boolean;
+}
+/**
+ * Polyfill manager for loading polyfills conditionally based on browser support
+ * Provides feature detection and conditional loading to avoid conflicts with existing implementations
+ */
+declare class PolyfillManager {
+    private config;
+    private detectionResults;
+    constructor(config?: Partial<PolyfillConfig>);
+    /**
+     * Load polyfills based on feature detection and configuration
+     */
+    loadPolyfills(): Promise<void>;
+    /**
+     * Get the results of feature detection
+     */
+    getDetectionResults(): FeatureDetectionResult | null;
+    /**
+     * Detect which features need polyfills
+     */
+    private detectFeatures;
+    /**
+     * Check if fetch polyfill is needed
+     */
+    private needsFetchPolyfill;
+    /**
+     * Check if Promise polyfill is needed
+     */
+    private needsPromisePolyfill;
+    /**
+     * Check if URL polyfill is needed
+     */
+    private needsUrlPolyfill;
+    /**
+     * Load fetch polyfill if not already present
+     */
+    private loadFetchPolyfill;
+    /**
+     * Load Promise polyfill if not already present
+     */
+    private loadPromisePolyfill;
+    /**
+     * Load URL polyfill if not already present
+     */
+    private loadUrlPolyfill;
+}
+
+/**
+ * Analytics and GTM Data Layer Types
+ *
+ * Provides type-safe event tracking for Google Tag Manager / Google Analytics
+ * integration throughout the quote journey lifecycle.
+ */
+
+/**
+ * Configuration for analytics tracking
+ */
+interface AnalyticsConfig {
+    /** Enable or disable analytics tracking (default: true if dataLayer exists) */
+    enabled?: boolean;
+    /** Custom data layer variable name (default: 'dataLayer') */
+    customDataLayer?: string;
+    /** Include personally identifiable information in events (default: false) */
+    includePersonalData?: boolean;
+    /** Enable debug logging to console (default: false) */
+    debug?: boolean;
+}
+/**
+ * Base properties included in all analytics events
+ */
+interface BaseAnalyticsEvent {
+    /** Event name for GTM trigger */
+    event: string;
+    /** Quote intent ID */
+    quote_id: string;
+    /** Product code (versioned) */
+    product_code?: string;
+    /** Product name */
+    product_name?: string;
+    /** Organisation slug */
+    organisation_slug?: string;
+    /** Organisation name */
+    organisation_name?: string;
+    /** Event timestamp (ISO 8601) */
+    timestamp: string;
+}
+/**
+ * Event: quote_started
+ * Triggered when a new quote intent is created
+ */
+interface QuoteStartedEvent extends BaseAnalyticsEvent {
+    event: 'quote_started';
+    /** Quote status */
+    quote_status: QuoteIntentState['status'];
+    /** Total number of form pages */
+    total_pages?: number;
+}
+/**
+ * Event: quote_form_progress
+ * Triggered when user completes a form page
+ */
+interface QuoteFormProgressEvent extends BaseAnalyticsEvent {
+    event: 'quote_form_progress';
+    /** Current page index (0-based) */
+    current_page: number;
+    /** Total number of pages */
+    total_pages: number;
+    /** Number of completed pages */
+    completed_pages: number;
+    /** Form completion percentage (0-100) */
+    completion_percentage: number;
+    /** Page title that was just completed */
+    page_title?: string;
+}
+/**
+ * Event: quote_calculated
+ * Triggered when quote calculation completes successfully
+ */
+interface QuoteCalculatedEvent extends BaseAnalyticsEvent {
+    event: 'quote_calculated';
+    /** Selected excess option ID */
+    excess_id?: string;
+    /** Selected excess amount */
+    excess_amount?: number;
+    /** Premium subtotal (before fees) */
+    premium_subtotal?: number;
+    /** Premium total (including fees) */
+    premium_total?: number;
+    /** Number of excess options available */
+    excess_options_count: number;
+    /** Number of payment options available */
+    payment_options_count: number;
+    /** Whether installment payments are available */
+    has_installments?: boolean;
+    /** Lowest available premium */
+    min_premium?: number;
+    /** Highest available premium */
+    max_premium?: number;
+}
+/**
+ * Event: quote_at_checkout
+ * Triggered when user reaches the checkout page
+ */
+interface QuoteAtCheckoutEvent extends BaseAnalyticsEvent {
+    event: 'quote_at_checkout';
+    /** Selected excess option ID */
+    excess_id: string;
+    /** Selected excess amount */
+    excess_amount: number;
+    /** Premium subtotal (before fees) */
+    premium_subtotal: number;
+    /** Premium total (including fees) */
+    premium_total: number;
+    /** Number of payment options available */
+    payment_options_count: number;
+    /** Whether installment payments are available */
+    has_installments: boolean;
+    /** Form completion percentage (should be 100) */
+    form_completion: number;
+    /** Fees breakdown */
+    fees?: Array<{
+        name: string;
+        type: string;
+        amount: number;
+    }>;
+}
+/**
+ * Event: quote_referred
+ * Triggered when a quote is referred and cannot proceed
+ */
+interface QuoteReferredEvent extends BaseAnalyticsEvent {
+    event: 'quote_referred';
+    /** Referral reason/message */
+    referral_reason?: string;
+    /** Number of referrals */
+    referrals_count: number;
+    /** Referral IDs */
+    referral_ids?: string[];
+}
+/**
+ * Event: payment_initiated
+ * Triggered when user clicks "Pay Now" and payment process begins
+ */
+interface PaymentInitiatedEvent extends BaseAnalyticsEvent {
+    event: 'payment_initiated';
+    /** Payment amount */
+    payment_amount: number;
+    /** Payment gateway code */
+    payment_gateway: string;
+    /** Payment gateway name */
+    payment_gateway_name?: string;
+    /** Selected excess amount */
+    excess_amount: number;
+    /** Payment frequency (monthly vs one-time) */
+    payment_frequency?: 'monthly' | 'one-time';
+    /** Amount due today */
+    amount_due_today?: number;
+    /** Number of installments (if applicable) */
+    installments_count?: number;
+}
+/**
+ * Event: payment_completed
+ * Triggered when payment is successfully completed
+ */
+interface PaymentCompletedEvent extends BaseAnalyticsEvent {
+    event: 'payment_completed';
+    /** Payment transaction ID */
+    transaction_id: string;
+    /** Payment amount */
+    payment_amount: number;
+    /** Payment gateway used */
+    payment_gateway?: string;
+    /** Premium total */
+    premium_total: number;
+    /** Excess amount */
+    excess_amount: number;
+}
+/**
+ * Event: payment_failed
+ * Triggered when payment fails or is declined
+ */
+interface PaymentFailedEvent extends BaseAnalyticsEvent {
+    event: 'payment_failed';
+    /** Payment transaction ID (if available) */
+    transaction_id?: string;
+    /** Payment amount attempted */
+    payment_amount?: number;
+    /** Payment gateway used */
+    payment_gateway?: string;
+    /** Payment status */
+    payment_status?: string;
+    /** Failure reason (if available) */
+    failure_reason?: string;
+}
+/**
+ * Union type of all possible analytics events
+ */
+type AnalyticsEvent = QuoteStartedEvent | QuoteFormProgressEvent | QuoteCalculatedEvent | QuoteAtCheckoutEvent | QuoteReferredEvent | PaymentInitiatedEvent | PaymentCompletedEvent | PaymentFailedEvent;
+/**
+ * Type for the global dataLayer array
+ */
+type DataLayer = Array<Record<string, any>>;
+/**
+ * Window interface extension for dataLayer
+ */
+declare global {
+    interface Window {
+        dataLayer?: DataLayer;
+        [key: string]: any;
+    }
+}
+
+/**
+ * Storage abstraction layer for browser storage APIs
+ */
+interface StorageAdapter {
+    /**
+     * Get a value from storage
+     */
+    get(key: string): string | null;
+    /**
+     * Set a value in storage
+     */
+    set(key: string, value: string): void;
+    /**
+     * Remove a value from storage
+     */
+    remove(key: string): void;
+    /**
+     * Check if storage is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Clear all storage
+     */
+    clear(): void;
+}
+/**
+ * localStorage implementation of StorageAdapter
+ */
+declare class LocalStorageAdapter implements StorageAdapter {
+    private available;
+    constructor();
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    clear(): void;
+    isAvailable(): boolean;
+    private checkAvailability;
+}
+/**
+ * sessionStorage implementation of StorageAdapter
+ */
+declare class SessionStorageAdapter implements StorageAdapter {
+    private available;
+    constructor();
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    clear(): void;
+    isAvailable(): boolean;
+    private checkAvailability;
+}
+/**
+ * In-memory fallback implementation when storage is not available
+ */
+declare class MemoryStorageAdapter implements StorageAdapter {
+    private storage;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    clear(): void;
+    isAvailable(): boolean;
+}
+
+/**
+ * Local state management for quote intents
+ */
+
+/**
+ * Configuration for LocalStateManager
+ */
+interface StateManagerConfig {
+    /** Default expiration time in milliseconds (default: 24 hours) */
+    defaultExpirationMs?: number;
+    /** Storage namespace (default: 'quote_intent') */
+    namespace?: string;
+}
+/**
+ * Local state manager for persisting quote intent data
+ */
+declare class LocalStateManager {
+    private static readonly DEFAULT_EXPIRATION_MS;
+    private static readonly DEFAULT_NAMESPACE;
+    private storageAdapter;
+    private config;
+    constructor(storageAdapter: StorageAdapter, config?: StateManagerConfig);
+    /**
+     * Save quote intent state for an organization
+     */
+    saveQuoteIntent(orgId: string, state: QuoteIntentState): void;
+    /**
+     * Get quote intent state for an organization
+     */
+    getQuoteIntent(orgId: string): QuoteIntentState | null;
+    /**
+     * Remove quote intent state for an organization
+     */
+    removeQuoteIntent(orgId: string): void;
+    /**
+     * Check if quote intent state is valid (not expired and has required fields)
+     */
+    isQuoteIntentValid(state: QuoteIntentState): boolean;
+    /**
+     * Get all quote intent states (for cleanup purposes)
+     */
+    getAllQuoteIntents(): Record<string, QuoteIntentState>;
+    /**
+     * Clean up expired quote intents
+     */
+    cleanupExpiredQuoteIntents(): void;
+    /**
+     * Check if storage is available
+     */
+    isStorageAvailable(): boolean;
+    /**
+     * Generate storage key for organization
+     */
+    private generateStorageKey;
+}
+/**
+ * Quote intent specific storage operations
+ */
+declare class QuoteIntentStore {
+    private stateManager;
+    constructor(stateManager: LocalStateManager);
+    /**
+     * Get existing quote intent or create a new one
+     */
+    getOrCreateQuoteIntent(orgId: string, createQuoteIntent: () => Promise<QuoteIntentState>, getQuoteIntent: (url: string) => Promise<QuoteIntentState>): Promise<QuoteIntentState>;
+    /**
+     * Update existing quote intent state
+     */
+    updateQuoteIntent(orgId: string, updates: Partial<QuoteIntentState>): QuoteIntentState | null;
+    /**
+     * Clear quote intent for organization
+     */
+    clearQuoteIntent(orgId: string): void;
+    /**
+     * Clear all expired quote intents
+     */
+    clearExpiredQuoteIntents(): void;
+    /**
+     * Check if quote intent exists and is valid
+     */
+    hasValidQuoteIntent(orgId: string): boolean;
+    /**
+     * Get quote intent URL if available
+     */
+    getQuoteIntentUrl(orgId: string): string | null;
+    /**
+     * Check if storage is available
+     */
+    isStorageAvailable(): boolean;
+}
+
+interface PerformanceMetrics {
+    bundleSize: {
+        esm: number;
+        umd: number;
+        cjs: number;
+        gzipped: {
+            esm: number;
+            umd: number;
+            cjs: number;
+        };
+    };
+    runtime: {
+        initializationTime: number;
+        apiCallTime: number;
+        memoryUsage: number;
+        averageApiCallTime: number;
+        totalApiCalls: number;
+    };
+    measurements: Record<string, number[]>;
+}
+interface MemoryInfo {
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+}
+interface ApiCallMetrics {
+    operation: string;
+    duration: number;
+    timestamp: number;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Performance monitoring class for tracking metrics
+ */
+declare class PerformanceMonitor {
+    private measurements;
+    private completedMeasurements;
+    private apiCallMetrics;
+    private initializationTime;
+    private static instance;
+    constructor();
+    /**
+     * Start measuring performance for a named operation
+     */
+    startMeasurement(name: string): void;
+    /**
+     * End measurement and return duration in milliseconds
+     */
+    endMeasurement(name: string): number;
+    /**
+     * Measure and record API call performance
+     */
+    measureApiCall<T>(operation: string, apiCall: () => Promise<T>): Promise<T>;
+    /**
+     * Get current memory usage information
+     */
+    measureMemoryUsage(): number;
+    /**
+     * Get detailed memory information if available
+     */
+    getDetailedMemoryInfo(): MemoryInfo | null;
+    /**
+     * Get all collected performance metrics
+     */
+    getMetrics(): PerformanceMetrics;
+    /**
+     * Get API call metrics for analysis
+     */
+    getApiCallMetrics(): ApiCallMetrics[];
+    /**
+     * Clear all collected metrics
+     */
+    clearMetrics(): void;
+    /**
+     * Generate performance report
+     */
+    generateReport(): string;
+    /**
+     * Get bundle sizes from build artifacts
+     */
+    static getBundleSizes(): Promise<PerformanceMetrics["bundleSize"]>;
+    private now;
+    static startMeasurement(name: string): void;
+    static endMeasurement(name: string): number;
+    static measureMemoryUsage(): number;
+    static measureApiCall<T>(operation: string, apiCall: () => Promise<T>): Promise<T>;
+    static getMetrics(): PerformanceMetrics;
+    static generateReport(): string;
+}
+
+declare enum ErrorType {
+    NETWORK_ERROR = "NETWORK_ERROR",
+    API_ERROR = "API_ERROR",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    STORAGE_ERROR = "STORAGE_ERROR",
+    TIMEOUT_ERROR = "TIMEOUT_ERROR",
+    MAINTENANCE_ERROR = "MAINTENANCE_ERROR"
+}
+/**
+ * Custom error class for InsureOS operations
+ */
+declare class InsureOSError extends Error {
+    type: ErrorType;
+    retryable: boolean;
+    statusCode?: number | undefined;
+    retryAfter?: string | undefined;
+    validationErrors?: Record<string, any> | undefined;
+    constructor(type: ErrorType, message: string, retryable?: boolean, statusCode?: number | undefined, retryAfter?: string | undefined, validationErrors?: Record<string, any> | undefined);
+}
+/**
+ * Error handling strategy for different error types
+ */
+declare class ErrorHandlingStrategy {
+    handleNetworkError(error: Error): InsureOSError;
+    handleApiError(response: Response): InsureOSError;
+    handleStorageError(error: Error): InsureOSError;
+    shouldRetry(error: InsureOSError): boolean;
+    getUserFriendlyMessage(error: InsureOSError): string;
+}
+
+type FixedVersionStrategyConfig = {
+    versionStrategy?: "fixed";
+    code: string;
+};
+type LatestVersionStrategyConfig = {
+    versionStrategy?: "latest";
+    code: string;
+};
+type VersionStrategyConfig = FixedVersionStrategyConfig | LatestVersionStrategyConfig;
+/** Version strategies for InsureOS products */
+declare enum VersionStrategy {
+    /** Gets the product based on an exact versioned code */
+    FIXED = "fixed",
+    /** Gets the latest active version of the product */
+    LATEST = "latest"
+}
+/**
+ * Enhanced configuration for mounting InsureOS quote functionality
+ */
+type ClientConfig = {
+    /** Org UUID */
+    orgId: string;
+    /** API URL */
+    apiBaseUrl?: string;
+    /** HTTP client configuration */
+    httpConfig?: Partial<HttpClientConfig>;
+};
+type MountConfig = ClientConfig & {
+    /** Existing quote intent url for loading (omit for new quote intents) */
+    quoteIntentUrl?: string;
+    /** Version strategy configuration */
+    product: VersionStrategyConfig;
+    /** Storage type preference */
+    storageType?: "localStorage" | "sessionStorage";
+    /** Polyfill configuration */
+    polyfillConfig?: Partial<PolyfillConfig>;
+    /** Analytics/GTM data layer configuration */
+    analyticsConfig?: AnalyticsConfig;
+    /** Enable debug mode for enhanced logging */
+    debug?: boolean;
+    /** Disable style injection */
+    disableStyles?: boolean;
+    /** Enable local state persistence (default: true) */
+    enableLocalState?: boolean;
+    /** Enable polyfills for older browsers (default: true) */
+    enablePolyfills?: boolean;
+    /** Enable performance monitoring (default: false) */
+    enablePerformanceMonitoring?: boolean;
+};
+type QuoteIntentState = {
+    id: string;
+    created_at: number;
+    updated_at: number;
+    expires_at: number;
+    org_id: string;
+    url: string;
+    calculate_url: string;
+    status: string;
+    product_id?: string;
+    form_definition?: FormDefinition;
+    form_data?: FormData;
+    organisation?: {
+        id: string;
+        created_at: string;
+        updated_at: string;
+        deleted_at: string | null;
+        name: string;
+        slug: string;
+        admin_email?: string | null;
+        phone?: string | null;
+        theme: {
+            css_url: string;
+        } | null;
+    };
+    payment_return?: {
+        paymentTransactionId: string | null;
+        paymentStatus: string | null;
+        transactionStatus?: any;
+    };
+    cached_result?: CalculationResponse;
+};
+
+declare class InsureOSQuoteWrapperClient {
+    private httpClient;
+    response: QuoteIntentResponse;
+    constructor(httpClient: EnhancedHttpClient, response: QuoteIntentResponse);
+    get(): Promise<QuoteIntentResponse>;
+    update(data: Record<string, any>): Promise<QuoteIntentResponse>;
+}
+declare class InsureOSWrapperClient {
+    private httpClient;
+    constructor(httpClient: EnhancedHttpClient);
+    createQuoteIntent(productCode: string, options?: {
+        cover_start_date?: string;
+    }): Promise<InsureOSQuoteWrapperClient>;
+}
+
+/**
+ * Enhanced InsureOS client with feature integration
+ */
+declare class InsureOSClient {
+    private sentryInitialized;
+    private analyticsManager;
+    constructor();
+    /**
+     * Initialize Sentry on first mount (only once)
+     */
+    private initializeSentryOnce;
+    private validateConfig;
+    /**
+     * Initialize analytics on first mount (only once)
+     */
+    private initializeAnalyticsOnce;
+    /**
+     * Mount enhanced InsureOS quote functionality to a DOM element
+     */
+    mount(element: HTMLElement, config: MountConfig): Promise<void>;
+    private createHttpClient;
+    createClient(config: ClientConfig): InsureOSWrapperClient;
+    private initializeFormContext;
+    /**
+     * Check if all form pages are completed and trigger calculation automatically
+     */
+    private handleAutoCalculationIfComplete;
+}
+declare const InsureOS: InsureOSClient;
+
+/**
+ * Retry strategy implementation with exponential backoff
+ */
+declare class RetryStrategy {
+    private config;
+    constructor(config: RetryConfig);
+    shouldRetry(error: Error, attempt: number): boolean;
+    getDelay(attempt: number, retryAfterHeader?: string): number;
+    isRetryableError(error: Error): boolean;
+}
+
+type ValidationError = {
+    field: string;
+    message: string;
+};
+type ValidationResult = {
+    isValid: boolean;
+    errors: ValidationError[];
+};
+type ServerValidationResponse = {
+    message?: string;
+    validation_errors?: Record<string, string[]>;
+    errors?: Record<string, string[]>;
+};
+/**
+ * Validates a single field value against its field definition
+ */
+declare function validateField(field: FormField, value: string | number | boolean | undefined): ValidationError[];
+/**
+ * Validates all fields on a page
+ */
+declare function validatePage(page: FormPage, formData: Record<string, any>): ValidationResult;
+/**
+ * Converts server validation response to our ValidationError format
+ * Supports both 'validation_errors' (422) and 'errors' (400) formats
+ */
+declare function parseServerValidationErrors(response: ServerValidationResponse | Record<string, string[]>): ValidationError[];
+/**
+ * Groups validation errors by field ID
+ */
+declare function groupErrorsByField(errors: ValidationError[]): Record<string, ValidationError[]>;
+
+type AppErrorType = "initialization" | "calculation" | "network" | "validation" | "maintenance" | "unknown";
+type AppErrorSeverity = "warning" | "error" | "critical";
+interface AppError {
+    id: string;
+    type: AppErrorType;
+    severity: AppErrorSeverity;
+    title: string;
+    message: string;
+    details?: string;
+    statusCode?: number;
+    retryable: boolean;
+    timestamp: number;
+    dismissed?: boolean;
+    trackingId?: string;
+}
+interface ServerErrorResponse {
+    statusCode: number;
+    message: string;
+    error?: string;
+    details?: any;
+}
+/**
+ * Creates a standardized app error from various error sources
+ */
+declare function createAppError(type: AppErrorType, error: any, customMessage?: string): AppError;
+/**
+ * Checks if an error indicates the app should show a fallback error page
+ */
+declare function shouldShowErrorPage(error: AppError): boolean;
+/**
+ * Checks if an error indicates the app should show the maintenance page
+ */
+declare function shouldShowMaintenancePage(error: AppError): boolean;
+/**
+ * Generates a user-friendly support message
+ */
+declare function getSupportMessage(error: AppError): string;
+
+/**
+ * Configuration for FormStateManager
+ */
+interface FormStateManagerConfig {
+    /** Auto-save interval in milliseconds (default: 1000) */
+    autoSaveInterval?: number;
+    /** Whether to enable auto-save (default: true) */
+    autoSave?: boolean;
+    /** Maximum retry attempts for failed saves (default: 3) */
+    maxRetryAttempts?: number;
+    /** Retry delay in milliseconds (default: 2000) */
+    retryDelay?: number;
+}
+type SaveType = "page" | "auto-save" | "full";
+type SubscriptionCallback = (state: FormStateManager) => void;
+declare class FormStateManager {
+    private quoteIntent;
+    httpClient: EnhancedHttpClient;
+    private subscribers;
+    private formData;
+    private pendingChanges;
+    private config;
+    private isCalculating;
+    private selectedExcessId;
+    private selectedPaymentOption;
+    private calculationResult;
+    private validationErrors;
+    private serverValidationErrors;
+    private generalErrors;
+    private lastCalculationFailed;
+    private autoSaveManager;
+    private persistenceManager;
+    private navigationManager;
+    private calculationManager;
+    private quoteIntentStore?;
+    constructor(quoteIntent: QuoteIntentState, httpClient: EnhancedHttpClient, quoteIntentStore?: QuoteIntentStore, config?: FormStateManagerConfig);
+    subscribe(callback: SubscriptionCallback): () => boolean;
+    loadFormProgress(): Promise<FormData>;
+    updatePageData(pageId: string, data: Record<string, any>): void;
+    updateFieldValue(pageId: string, fieldId: string, value: any): void;
+    updateFieldAnswer(pageId: string, fieldId: string, answer: string): void;
+    restoreFormProgress(data: FormData): void;
+    restoreCalculationResult(result: CalculationResponse): void;
+    private processRatingFactorMappings;
+    private applyDerivationRule;
+    private calculateAge;
+    saveFormData(force?: boolean, saveType?: SaveType): Promise<void>;
+    canNavigateToPage(pageIndex: number): boolean;
+    navigateToPage(pageIndex: number): Promise<boolean>;
+    navigateToNextPage(): Promise<boolean>;
+    navigateToPreviousPage(): Promise<boolean>;
+    getPageCompletionStatus(): {
+        totalPages: number;
+        currentPage: number;
+        completedPages: number[];
+        percentComplete: number;
+    };
+    getFormProgress(): FormData;
+    getFormDefinition(): FormDefinition;
+    getTotalPages(): number;
+    getCurrentPageIndex(): number;
+    isAutoSavePaused(): boolean;
+    isUserTyping(): boolean;
+    getIsCalculating(): boolean;
+    hasCalculationResponse(): boolean;
+    getCalculationResult(): CalculationResponse | undefined;
+    getConsecutiveFailures(): number;
+    getSelectedExcessId(): string | null;
+    setSelectedExcessId(excessId: string | null): void;
+    getSelectedPaymentOption(): PaymentOption | null;
+    setSelectedPaymentOption(paymentOption: PaymentOption | null): void;
+    hasPendingChanges(): boolean;
+    validateCurrentPage(): ValidationError[];
+    validateField(pageId: string, fieldId: string, value: any): ValidationError[];
+    getValidationErrors(): ValidationError[];
+    getFieldErrors(fieldId: string): ValidationError[];
+    hasErrors(): boolean;
+    hasFieldErrors(fieldId: string): boolean;
+    clearValidationErrors(): void;
+    setServerValidationErrors(errors: ValidationError[]): void;
+    clearServerValidationErrors(): void;
+    getGeneralErrors(): AppError[];
+    addGeneralError(error: AppError): void;
+    dismissGeneralError(errorId: string): void;
+    clearGeneralErrors(): void;
+    hasGeneralErrors(): boolean;
+    hasLastCalculationFailed(): boolean;
+    dispose(): void;
+    /**
+     * Filter out hidden field values before calculation
+     * This ensures hidden fields don't affect calculations
+     */
+    private filterHiddenFieldsAndSave;
+    calculateQuote(): Promise<CalculationResponse | undefined>;
+    private notify;
+    private updateFormDataInternal;
+    private createEmptyFormData;
+    private getPersistedCalculationFailureState;
+    private persistCalculationFailureState;
+    reset(): void;
+    getQuoteIntent(): QuoteIntentState;
+    updateQuoteIntent(updates: Partial<QuoteIntentState>): void;
+    clearStoredQuoteIntent(): void;
+    initiatePayment(paymentRequest: PaymentInitiationRequest): Promise<any>;
+    getPaymentStatus(transactionId: string): Promise<any>;
+    startPaymentStatusPolling(transactionId: string, onStatusUpdate: (status: any) => void, maxPolls?: number): () => void;
+}
+
+interface SentryConfig {
+    dsn: string;
+    environment?: string;
+    release?: string;
+    enabled?: boolean;
+    sampleRate?: number;
+    tracesSampleRate?: number;
+    bundleUrlPatterns?: RegExp[];
+}
+/**
+ * Initialize Sentry with isolated configuration for embedded widget use
+ *
+ * IMPORTANT: This is configured to ONLY capture errors from our widget code,
+ * not from the host page. This prevents conflicts with host page Sentry installations.
+ */
+declare function initializeSentry(config: SentryConfig): void;
+/**
+ * Capture an exception to Sentry
+ */
+declare function captureException(error: Error | unknown, context?: Record<string, any>): void;
+/**
+ * Capture a message to Sentry
+ */
+declare function captureMessage(message: string, level?: Sentry.SeverityLevel, context?: Record<string, any>): void;
+/**
+ * Set user context for Sentry
+ */
+declare function setUser(user: {
+    id?: string;
+    email?: string;
+    username?: string;
+} | null): void;
+/**
+ * Add a breadcrumb to Sentry
+ */
+declare function addBreadcrumb(breadcrumb: {
+    message: string;
+    category?: string;
+    level?: Sentry.SeverityLevel;
+    data?: Record<string, any>;
+}): void;
+/**
+ * Set a custom tag in Sentry
+ */
+declare function setTag(key: string, value: string): void;
+/**
+ * Check if Sentry is initialized
+ */
+declare function isSentryInitialized(): boolean;
+
+interface ThemeConfig {
+    slug: string;
+    theme_url: string;
+}
+interface ParsedTheme {
+    variables: Record<string, string>;
+    classRules: string;
+    mappedVariables: Record<string, string>;
+}
+/**
+ * Theme loader utility for loading organization-specific CSS themes
+ */
+declare class ThemeLoader {
+    private static loadedThemes;
+    /**
+     * Mapping from organization theme variables to InsureOS prefixed variables
+     */
+    private static variableMapping;
+    /**
+     * Load theme CSS from organization configuration
+     */
+    static loadTheme(themeConfig: ThemeConfig): Promise<void>;
+    /**
+     * Parse CSS content to extract variables and class rules
+     */
+    private static parseCSSContent;
+    /**
+     * Apply parsed theme to document and update base variables
+     */
+    private static applyParsedTheme;
+    /**
+     * Apply class rules to document
+     */
+    private static applyClassRules;
+    /**
+     * Inject original CSS for unmapped variables and additional styles
+     */
+    private static injectOriginalCSS;
+    /**
+     * Remove theme CSS from document
+     */
+    static removeTheme(slug: string): void;
+    /**
+     * Check if theme is loaded
+     */
+    static isThemeLoaded(slug: string): boolean;
+    /**
+     * Get list of loaded themes
+     */
+    static getLoadedThemes(): string[];
+}
+
+/**
+ * Data Layer Helper
+ *
+ * Provides safe, type-safe access to the GTM/GA data layer for analytics tracking.
+ * Gracefully degrades if data layer is not present on the page.
+ */
+
+/**
+ * Data Layer Manager
+ *
+ * Handles pushing events to the GTM/GA data layer with proper error handling
+ * and optional debug logging.
+ */
+declare class DataLayerManager {
+    private config;
+    private dataLayerAvailable;
+    constructor(config?: AnalyticsConfig);
+    /**
+     * Initialize the data layer if it doesn't exist
+     */
+    private initializeDataLayer;
+    /**
+     * Check if analytics is enabled and data layer is available
+     */
+    isEnabled(): boolean;
+    /**
+     * Get the data layer array
+     */
+    private getDataLayer;
+    /**
+     * Push an event to the data layer
+     */
+    push(event: AnalyticsEvent): void;
+    /**
+     * Remove personally identifiable information from event
+     */
+    private removePII;
+    /**
+     * Log debug messages if debug mode is enabled
+     */
+    private logDebug;
+    /**
+     * Reset/clear the data layer (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<Required<AnalyticsConfig>>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<AnalyticsConfig>): void;
+}
+
+/**
+ * Analytics Event Tracking Functions
+ *
+ * Provides high-level functions to track specific events throughout the quote
+ * journey lifecycle. These functions extract relevant data from quote intents,
+ * calculations, and payments to create rich, structured analytics events.
+ */
+
+/**
+ * Initialize analytics with configuration
+ */
+declare function initializeAnalytics(manager: DataLayerManager): void;
+/**
+ * Get the analytics instance
+ */
+declare function getAnalytics(): DataLayerManager | null;
+/**
+ * Track quote started event
+ */
+declare function trackQuoteStarted(quoteIntent: QuoteIntentState): void;
+/**
+ * Track form progress event
+ */
+declare function trackFormProgress(quoteIntent: QuoteIntentState, currentPage: number, completedPages: number[], pageTitle?: string): void;
+/**
+ * Track quote calculated event
+ */
+declare function trackQuoteCalculated(quoteIntent: QuoteIntentState, calculationResponse: CalculationResponse): void;
+/**
+ * Track quote at checkout event
+ */
+declare function trackQuoteAtCheckout(quoteIntent: QuoteIntentState, selectedExcess: CalculationExcessOption, paymentOptionsCount: number, hasInstallments: boolean, formCompletion: number): void;
+/**
+ * Track quote referred event
+ */
+declare function trackQuoteReferred(quoteIntent: QuoteIntentState, calculationResponse: CalculationResponse): void;
+/**
+ * Track payment initiated event
+ */
+declare function trackPaymentInitiated(quoteIntent: QuoteIntentState, paymentOption: PaymentOption, gatewayName?: string, excessAmount?: number): void;
+/**
+ * Track payment completed event
+ */
+declare function trackPaymentCompleted(quoteIntent: QuoteIntentState, transactionId: string, paymentAmount: number, paymentGateway?: string, premiumTotal?: number, excessAmount?: number): void;
+/**
+ * Track payment failed event
+ */
+declare function trackPaymentFailed(quoteIntent: QuoteIntentState, transactionId?: string, paymentAmount?: number, paymentGateway?: string, paymentStatus?: string, failureReason?: string): void;
+
+export { DataLayerManager, EnhancedHttpClient, ErrorHandlingStrategy, ErrorType, FormStateManager, InsureOS, InsureOSClient, InsureOSError, LocalStateManager, LocalStorageAdapter, MemoryStorageAdapter, PerformanceMonitor, PolyfillManager, RetryStrategy, SessionStorageAdapter, ThemeLoader, VersionStrategy, addBreadcrumb, captureException, captureMessage, createAppError, getAnalytics, getSupportMessage, groupErrorsByField, initializeAnalytics, initializeSentry, isSentryInitialized, parseServerValidationErrors, setTag, setUser, shouldShowErrorPage, shouldShowMaintenancePage, trackFormProgress, trackPaymentCompleted, trackPaymentFailed, trackPaymentInitiated, trackQuoteAtCheckout, trackQuoteCalculated, trackQuoteReferred, trackQuoteStarted, validateField, validatePage };
+export type { AnalyticsConfig, AnalyticsEvent, ApiCallMetrics, AppError, AppErrorSeverity, AppErrorType, BaseAnalyticsEvent, DataLayer, FormStateManagerConfig, HttpClientConfig, MemoryInfo, MountConfig, ParsedTheme, PaymentCompletedEvent, PaymentFailedEvent, PaymentInitiatedEvent, PerformanceMetrics, PolyfillConfig, QuoteAtCheckoutEvent, QuoteCalculatedEvent, QuoteFormProgressEvent, QuoteIntentState, QuoteReferredEvent, QuoteStartedEvent, RetryConfig, SentryConfig, ServerErrorResponse, ServerValidationResponse, StorageAdapter, ThemeConfig, ValidationError, ValidationResult, VersionStrategyConfig };