@akson/cortex-landing-hooks/dist/data/index.d.ts

React hooks for landing pages - device detection, API calls, form submission, analytics, and performance

interface ApiCallOptions<T> {
    url: string;
    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    headers?: Record<string, string>;
    retries?: number;
    retryDelay?: number;
    onSuccess?: (data: T) => void;
    onError?: (error: Error) => void;
    transformResponse?: (data: unknown) => T;
    /**
     * Skip retry for certain HTTP status codes (default: client errors 4xx)
     */
    skipRetryForStatus?: number[];
}
interface ApiCallResult<T> {
    data: T | null;
    error: Error | null;
    loading: boolean;
    execute: (body?: Record<string, unknown>) => Promise<T | null>;
    reset: () => void;
}
/**
 * Hook for making API calls with built-in error handling, retries, and loading states
 */
declare function useApiCall<T = any>(options: ApiCallOptions<T>): ApiCallResult<T>;
interface AuthenticatedApiCallOptions<T> extends Omit<ApiCallOptions<T>, 'headers'> {
    headers?: Record<string, string>;
    /**
     * Function to get auth token
     */
    getToken?: () => string | null;
    /**
     * Token storage key (default: 'auth_token')
     */
    tokenKey?: string;
    /**
     * Custom token header name (default: 'Authorization')
     */
    tokenHeader?: string;
    /**
     * Token prefix (default: 'Bearer ')
     */
    tokenPrefix?: string;
}
/**
 * Hook for making authenticated API calls with JWT token
 */
declare function useAuthenticatedApiCall<T = any>(options: AuthenticatedApiCallOptions<T>): ApiCallResult<T>;
interface RestApiOptions<T> extends Omit<ApiCallOptions<T>, 'url'> {
    /**
     * Base URL for the API
     */
    baseUrl: string;
    /**
     * API version or prefix (e.g., 'v1', 'api/v1')
     */
    apiVersion?: string;
}
/**
 * Hook for RESTful API calls with consistent base URL and versioning
 */
declare function useRestApi<T = any>(endpoint: string, options: RestApiOptions<T>): ApiCallResult<T>;

/**
 * Lead Data Management Hook
 * Simplified lead data management for landing pages
 * Migrated from /app/hooks/use-lead-data.ts
 */
interface UseLeadDataReturn {
    leadData: Record<string, unknown> | null;
    updateField: (fieldName: string, fieldValue: unknown, formData?: Record<string, unknown>) => void;
    updateImmediate: (formData: Record<string, unknown>) => Promise<boolean>;
    isLoading: boolean;
    clearData: () => void;
    hasData: boolean;
}
/**
 * Hook for lead data management with localStorage persistence
 *
 * Features:
 * - Automatic localStorage persistence
 * - Real-time updates via listeners
 * - Simple API simulation
 * - No external dependencies
 */
declare function useLeadData(phoneNumber: string | null): UseLeadDataReturn;

/**
 * Document upload hook
 * Generic document upload functionality for landing pages
 * Migrated from /app/hooks/use-document-upload.ts
 */
interface UploadProgress {
    isUploading: boolean;
    progress: number;
    error?: string;
}
interface UploadResult {
    success: boolean;
    filePath?: string;
    publicUrl?: string;
    fileName?: string;
    fileSize?: number;
    fileType?: string;
    error?: string;
}
interface UseDocumentUploadOptions {
    uploadEndpoint?: string;
    progressUpdateInterval?: number;
    onUploadStart?: (file: File) => void;
    onUploadSuccess?: (result: UploadResult) => void;
    onUploadError?: (error: string) => void;
}
interface UseDocumentUploadReturn {
    uploadProgress: UploadProgress;
    uploadDocument: (file: File, leadId?: string, additionalData?: Record<string, any>) => Promise<UploadResult>;
    resetUpload: () => void;
}
declare function useDocumentUpload(options?: UseDocumentUploadOptions): UseDocumentUploadReturn;

/**
 * Dashboard Data Hook
 * Generic dashboard data fetching with configurable endpoints and structure
 * Migrated from /app/hooks/use-dashboard-data.ts
 */
interface DashboardTraffic {
    total: number;
    trend: number;
    hourly?: Array<{
        hour: number;
        value: number;
    }>;
    sources?: Array<{
        source: string;
        visits: number;
        percentage: number;
    }>;
}
interface DashboardConversion {
    rate: number;
    trend: number;
}
interface DashboardFunnel {
    visitors: number;
    formStarted: number;
    formCompleted: number;
    quoteRequested: number;
    converted: number;
}
interface DashboardAOV {
    value: number;
    trend: number;
}
interface DashboardWhatsApp {
    clickRate: number;
    trend: number;
    todayClicks: number;
}
interface DashboardDevice {
    deviceType: string;
    sessions: number;
    conversionRate: number;
}
interface DashboardChannel {
    channel: string;
    visits: number;
    conversions: number;
    cost: number;
    revenue: number;
    roi: number;
}
interface DashboardData {
    traffic: DashboardTraffic;
    conversion: DashboardConversion;
    funnel: DashboardFunnel;
    aov: DashboardAOV;
    whatsapp: DashboardWhatsApp;
    devices: DashboardDevice[];
    channels: DashboardChannel[];
    [key: string]: any;
}
interface UseDashboardDataOptions {
    endpoint?: string;
    timeRange?: string;
    refreshInterval?: number;
    authToken?: string;
    headers?: Record<string, string>;
    onError?: (error: Error) => void;
    onSuccess?: (data: DashboardData) => void;
    transformData?: (rawData: any) => DashboardData;
}
interface UseDashboardDataReturn {
    data: DashboardData | null;
    loading: boolean;
    error: Error | null;
    refetch: () => Promise<void>;
}
declare function useDashboardData(options?: UseDashboardDataOptions): UseDashboardDataReturn;
declare function createMockDashboardData(): DashboardData;

/**
 * Realtime Data Hook
 * Generic realtime data synchronization for landing pages
 * Migrated and simplified from /app/hooks/use-supabase-realtime.ts
 */
interface RealtimePayload<T = Record<string, unknown>> {
    eventType: 'INSERT' | 'UPDATE' | 'DELETE';
    new?: T;
    old?: T;
    table: string;
    timestamp: string;
    [key: string]: any;
}
interface UseRealtimeDataOptions<T = Record<string, unknown>> {
    table: string;
    filter?: string;
    eventType?: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
    onData?: (payload: RealtimePayload<T>) => void;
    onError?: (error: Error) => void;
    onConnected?: () => void;
    onDisconnected?: () => void;
    enabled?: boolean;
    reconnectInterval?: number;
}
interface UseRealtimeDataReturn {
    isConnected: boolean;
    lastUpdate: Date | null;
    error: Error | null;
    connect: () => void;
    disconnect: () => void;
    sendMessage: (message: any) => void;
}
/**
 * Generic realtime data hook using WebSocket
 * Can be adapted to work with different realtime services
 */
declare function useRealtimeData<T = Record<string, unknown>>(options: UseRealtimeDataOptions<T>): UseRealtimeDataReturn;
/**
 * Hook for localStorage-based auto-save with periodic sync
 * Generic version that can work with any sync endpoint
 */
interface UseLocalStorageSyncOptions {
    key: string;
    syncInterval?: number;
    syncEndpoint?: string;
    onSyncSuccess?: (data: any) => void;
    onSyncError?: (error: Error) => void;
    transformBeforeSync?: (data: any) => any;
}
interface UseLocalStorageSyncReturn {
    saveToLocal: (data: Record<string, unknown>) => void;
    getFromLocal: () => Record<string, unknown> | null;
    syncToRemote: () => Promise<boolean>;
    lastSyncTime: Date | null;
    isSyncing: boolean;
}
declare function useLocalStorageSync(options: UseLocalStorageSyncOptions): UseLocalStorageSyncReturn;

export { type ApiCallOptions, type ApiCallResult, type AuthenticatedApiCallOptions, type DashboardAOV, type DashboardChannel, type DashboardConversion, type DashboardData, type DashboardDevice, type DashboardFunnel, type DashboardTraffic, type DashboardWhatsApp, type RealtimePayload, type RestApiOptions, type UploadProgress, type UploadResult, type UseDashboardDataOptions, type UseDashboardDataReturn, type UseDocumentUploadOptions, type UseDocumentUploadReturn, type UseLocalStorageSyncOptions, type UseLocalStorageSyncReturn, type UseRealtimeDataOptions, type UseRealtimeDataReturn, createMockDashboardData, useApiCall, useAuthenticatedApiCall, useDashboardData, useDocumentUpload, useLeadData, useLocalStorageSync, useRealtimeData, useRestApi };