@deepfrog/pangents-widget 2.1.3 → 2.1.5

package/dist/services/auth/session.d.ts

@@ -0,0 +1,44 @@
+export interface LoginCredentials {
+    email: string;
+    password: string;
+}
+export interface LoginResponse {
+    accessToken: string;
+    refreshToken: string;
+    user: User;
+}
+export interface User {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+    permissions: string[];
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    user: User | null;
+    loading: boolean;
+    error: string | null;
+}
+declare class AuthSession {
+    private state;
+    private listeners;
+    constructor();
+    private initializeSession;
+    login(credentials: LoginCredentials): Promise<void>;
+    logout(): void;
+    hasPermission(permission: string): boolean;
+    hasRole(role: string): boolean;
+    getState(): AuthState;
+    subscribe(listener: (state: AuthState) => void): () => void;
+    private setState;
+    private setupEventListeners;
+}
+export declare const authSession: AuthSession;
+export declare const login: (credentials: LoginCredentials) => Promise<void>;
+export declare const logout: () => void;
+export declare const getAuthState: () => AuthState;
+export declare const hasPermission: (permission: string) => boolean;
+export declare const hasRole: (role: string) => boolean;
+export declare const subscribeToAuth: (listener: (state: AuthState) => void) => () => void;
+export {};

package/dist/services/auth/tokens.d.ts

@@ -0,0 +1,25 @@
+interface JWTPayload {
+    exp: number;
+    iat: number;
+    sub: string;
+    scope?: string;
+    user_id?: string;
+    [key: string]: any;
+}
+export declare const getAccessToken: () => string | null;
+export declare const getRefreshToken: () => string | null;
+export declare const setTokens: (accessToken: string, refreshToken?: string) => void;
+export declare const setAuthTokenFromResponse: (response: {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+}) => void;
+export declare const setBearerToken: (bearerToken: string) => void;
+export declare const clearTokens: () => void;
+export declare const isTokenExpired: (token?: string) => boolean;
+export declare const getTokenExpiry: () => number | null;
+export declare const getTokenPayload: (token?: string) => JWTPayload | null;
+export declare const refreshAccessToken: () => Promise<string | null>;
+export declare const setupAutoRefresh: () => void;
+export declare const clearAutoRefresh: () => void;
+export {};

package/dist/services/cache/ApiKeyTracker.d.ts

@@ -0,0 +1,78 @@
+/**
+ * API Key Tracker Service
+ *
+ * This service tracks API key changes and manages cache invalidation
+ * when the API key changes between sessions or page reloads.
+ */
+export interface ApiKeyChangeEvent {
+    previousKey: string | null;
+    currentKey: string | null;
+    timestamp: number;
+    reason: 'initial_load' | 'key_change' | 'page_reload';
+}
+export type ApiKeyChangeListener = (event: ApiKeyChangeEvent) => void;
+/**
+ * Service to track API key changes and manage cache alignment
+ */
+export declare class ApiKeyTracker {
+    private static instance;
+    private currentApiKey;
+    private listeners;
+    private initialized;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): ApiKeyTracker;
+    /**
+     * Initialize the tracker with the current API key
+     */
+    initialize(apiKey: string | null): void;
+    /**
+     * Update the current API key and check for changes
+     */
+    updateApiKey(newApiKey: string | null): boolean;
+    /**
+     * Get the current API key
+     */
+    getCurrentApiKey(): string | null;
+    /**
+     * Check if the API key has changed since last check
+     */
+    hasApiKeyChanged(apiKey: string | null): boolean;
+    /**
+     * Subscribe to API key change events
+     */
+    subscribe(listener: ApiKeyChangeListener): () => void;
+    /**
+     * Get cache alignment information
+     */
+    getCacheAlignment(): {
+        currentApiKey: string | null;
+        cacheApiKey: string | null;
+        isAligned: boolean;
+        lastUpdate: number;
+    };
+    /**
+     * Mark cache as aligned with current API key
+     */
+    markCacheAligned(): void;
+    /**
+     * Check if cache needs to be cleared due to API key mismatch
+     */
+    shouldClearCache(): boolean;
+    /**
+     * Reset the tracker (useful for testing)
+     */
+    reset(): void;
+    /**
+     * Private helper methods
+     */
+    private getStoredApiKey;
+    private storeApiKey;
+    private getCacheAlignmentInfo;
+    private setCacheAlignmentInfo;
+    private notifyListeners;
+    private clearStoredData;
+}
+export declare const apiKeyTracker: ApiKeyTracker;

package/dist/services/middleware/__tests__/enhancedErrorHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/middleware/enhancedErrorHandler.d.ts

@@ -0,0 +1,123 @@
+import React from 'react';
+import type { ApiError } from '../types/api';
+export interface ErrorContext {
+    component?: string;
+    action?: string;
+    userId?: string;
+    timestamp: string;
+    userAgent: string;
+    url: string;
+    apiKey?: string;
+}
+export interface ErrorReport {
+    error: ApiError;
+    context: ErrorContext;
+    stack?: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+}
+declare class EnhancedErrorHandler {
+    private errorQueue;
+    private isOnline;
+    private maxQueueSize;
+    private retryAttempts;
+    private retryDelay;
+    private circuitBreaker;
+    private rateLimiter;
+    private reportingEnabled;
+    private duplicateErrorCache;
+    private readonly duplicateTimeWindow;
+    constructor();
+    private setupEventListeners;
+    private validateApiKeyBeforeRequest;
+    private generateErrorFingerprint;
+    private isDuplicateError;
+    handleApiError(error: any, context?: Partial<ErrorContext>): ApiError;
+    handleJavaScriptError(error: Error, context?: Partial<ErrorContext>): void;
+    private determineSeverity;
+    private reportError;
+    private flushErrorQueue;
+    private showUserNotification;
+    private canRetryError;
+    private getUserFriendlyMessage;
+    enableReporting(): void;
+    disableReporting(): void;
+    getQueueSize(): number;
+    getCircuitBreakerState(): string;
+    getRemainingRateLimit(): number;
+    clearQueue(): void;
+    forceFlush(): Promise<void>;
+}
+declare const enhancedErrorHandler: EnhancedErrorHandler;
+export declare const handleApiError: (error: any, context?: Partial<ErrorContext>) => ApiError;
+export declare const handleJavaScriptError: (error: Error, context?: Partial<ErrorContext>) => void;
+export declare const enableErrorReporting: () => void;
+export declare const disableErrorReporting: () => void;
+export declare const getErrorQueueSize: () => number;
+export declare const getCircuitBreakerState: () => string;
+export declare const getRemainingRateLimit: () => number;
+export declare const clearErrorQueue: () => void;
+export declare const forceFlushErrors: () => Promise<void>;
+export declare const withErrorBoundary: (Component: React.ComponentType<any>, ErrorFallback?: React.ComponentType<any>) => {
+    new (props: any): {
+        componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+        render(): import("react/jsx-runtime").JSX.Element;
+        context: unknown;
+        setState<K extends "error" | "hasError">(state: {
+            hasError: boolean;
+            error?: Error;
+        } | ((prevState: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>, props: Readonly<any>) => {
+            hasError: boolean;
+            error?: Error;
+        } | Pick<{
+            hasError: boolean;
+            error?: Error;
+        }, K>) | Pick<{
+            hasError: boolean;
+            error?: Error;
+        }, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<any>;
+        state: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{
+            hasError: boolean;
+            error?: Error;
+        }>, nextContext: any): void;
+    };
+    getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+        error: Error;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default enhancedErrorHandler;

package/dist/services/middleware/errorHandler.d.ts

@@ -0,0 +1 @@
+export { handleApiError, handleJavaScriptError, enableErrorReporting, disableErrorReporting, getErrorQueueSize, getCircuitBreakerState, getRemainingRateLimit, clearErrorQueue, forceFlushErrors, withErrorBoundary, type ErrorContext, type ErrorReport, } from './enhancedErrorHandler';

package/dist/services/middleware/responseFormatter.d.ts

@@ -0,0 +1,61 @@
+import { ApiResponse, PaginatedResponse } from '../types/api';
+declare class ResponseFormatter {
+    formatResponse<T>(data: any): ApiResponse<T>;
+    formatPaginatedResponse<T>(data: T[], pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages?: number;
+    }): PaginatedResponse<T>;
+    formatErrorResponse(error: any): ApiResponse<null>;
+    transformResponseData<T>(data: any): T;
+    transformRequestData(data: any): any;
+    private toCamelCase;
+    private toSnakeCase;
+    validateResponse<T>(response: any): response is ApiResponse<T>;
+    validatePaginatedResponse<T>(response: any): response is PaginatedResponse<T>;
+    extractData<T>(response: ApiResponse<T>): T;
+    extractPaginatedData<T>(response: PaginatedResponse<T>): {
+        data: T[];
+        pagination: PaginatedResponse<T>['pagination'];
+    };
+    mergeResponses<T>(responses: ApiResponse<T>[]): ApiResponse<T[]>;
+    createResponseWithMetadata<T>(data: T, metadata?: Record<string, any>): ApiResponse<T> & {
+        metadata: Record<string, any>;
+    };
+    formatFileUploadResponse(file: File, uploadResult: any): ApiResponse<{
+        filename: string;
+        originalName: string;
+        size: number;
+        mimeType: string;
+        url?: string;
+        id?: string;
+    }>;
+    formatSearchResponse<T>(data: T[], filters: Record<string, any>, pagination: {
+        page: number;
+        limit: number;
+        total: number;
+    }): PaginatedResponse<T> & {
+        filters: Record<string, any>;
+    };
+}
+export declare const responseFormatter: ResponseFormatter;
+export declare const formatResponse: <T>(data: any) => ApiResponse<T>;
+export declare const formatPaginatedResponse: <T>(data: T[], pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages?: number;
+}) => PaginatedResponse<T>;
+export declare const formatErrorResponse: (error: any) => ApiResponse<null>;
+export declare const transformResponseData: <T>(data: any) => T;
+export declare const transformRequestData: (data: any) => any;
+export declare const validateResponse: <T>(response: any) => response is ApiResponse<T>;
+export declare const extractData: <T>(response: ApiResponse<T>) => T;
+export declare const extractPaginatedData: <T>(response: PaginatedResponse<T>) => {
+    data: T[];
+    pagination: PaginatedResponse<T_1>["pagination"];
+};
+export declare const responseInterceptor: (response: any) => any;
+export declare const requestInterceptor: (config: any) => any;
+export {};

package/dist/services/mock/config.d.ts

@@ -0,0 +1,14 @@
+export declare const MOCK_CONFIG: {
+    USE_MOCK: boolean;
+    NETWORK_DELAY: number;
+    MOCK_USERS: {
+        email: string;
+        name: string;
+        otp: string;
+    }[];
+    MOCK_API_KEYS: string[];
+    OTP_EXPIRY: number;
+    TOKEN_EXPIRY: number;
+};
+export declare const isMockEnabled: () => boolean;
+export default MOCK_CONFIG;

package/dist/services/mock/index.d.ts

@@ -0,0 +1,7 @@
+export { MOCK_CONFIG, isMockEnabled } from './config';
+export { MockAuthService } from './mockAuthService';
+export { MockApiKeyValidationService } from './mockApiKeyService';
+export * from './mockData';
+export { default as mockConfig } from './config';
+export { default as mockAuthService } from './mockAuthService';
+export { default as mockApiKeyService } from './mockApiKeyService';

package/dist/services/mock/mockApiKeyService.d.ts

@@ -0,0 +1,49 @@
+import type { ApiKeyValidationResponse } from '../api/apiKeyValidation';
+import type { ApiResponse } from '../types/api.d.ts';
+export declare class MockApiKeyValidationService {
+    /**
+     * Mock: Validate API key
+     */
+    static validateApiKey(apiKey: string): Promise<{
+        isValid: boolean;
+        response?: ApiKeyValidationResponse;
+        error?: string;
+        fromCache?: boolean;
+    }>;
+    /**
+     * Mock: Make validation request (internal)
+     */
+    static makeValidationRequest(apiKey: string): Promise<ApiResponse<ApiKeyValidationResponse>>;
+    static clearCache(): void;
+    static getCacheStats(): {
+        totalCached: number;
+        validCached: number;
+        expiredCached: number;
+    };
+    static getMetrics(): {
+        totalRequests: number;
+        cacheHits: number;
+        cacheMisses: number;
+        validationSuccesses: number;
+        validationFailures: number;
+        networkErrors: number;
+        averageResponseTime: number;
+        lastRequestTime: number;
+        cacheHitRate: number;
+        successRate: number;
+        rateLimitInfo: {
+            remainingRequests: number;
+            resetTime: number;
+            isLimited: boolean;
+        };
+    };
+    static resetMetrics(): void;
+    static prevalidateApiKey(apiKey: string): Promise<void>;
+    static validateMultipleApiKeys(apiKeys: string[]): Promise<Array<{
+        apiKey: string;
+        isValid: boolean;
+        response?: ApiKeyValidationResponse;
+        error?: string;
+    }>>;
+}
+export default MockApiKeyValidationService;

package/dist/services/mock/mockAuthService.d.ts

@@ -0,0 +1,12 @@
+import type { Login2FAResponse, VerifyOtpResponse } from '../api/authService';
+export declare class MockAuthService {
+    /**
+     * Mock: Send OTP to user's email for 2FA login
+     */
+    static login2FA(username: string): Promise<Login2FAResponse>;
+    /**
+     * Mock: Verify OTP and get authentication token
+     */
+    static verifyOTP(identifier: string, otp: string): Promise<VerifyOtpResponse>;
+}
+export default MockAuthService;

package/dist/services/mock/mockData.d.ts

@@ -0,0 +1,87 @@
+export declare const otpStore: Map<string, {
+    otp: string;
+    expiresAt: number;
+}>;
+export declare const generateMockToken: (email: string) => string;
+export declare const generateOTP: () => string;
+export declare const getMockApiKeyValidationResponse: (apiKey: string, isValid: boolean) => {
+    success: boolean;
+    data: {
+        _id: string;
+        created_at: string;
+        updated_at: string;
+        status: boolean;
+        api_key_status: "active" | "inactive";
+    };
+    message: string;
+    status: number;
+    timestamp: string;
+};
+export declare const getMockLogin2FAResponse: (email: string) => {
+    status: "otp_sent";
+    delivery: "email";
+    message: string;
+};
+export declare const getMockVerifyOTPResponse: (email: string) => {
+    data: {
+        _id: string;
+        created_at: string;
+        updated_at: string;
+        access_token: string;
+        token_type: "bearer";
+        expires_in: number;
+    };
+};
+export declare const findMockUser: (email: string) => {
+    email: string;
+    name: string;
+    otp: string;
+};
+export declare const isValidMockApiKey: (apiKey: string) => boolean;
+export declare const storeOTP: (email: string, otp: string) => void;
+export declare const verifyStoredOTP: (email: string, otp: string) => boolean;
+declare const _default: {
+    otpStore: Map<string, {
+        otp: string;
+        expiresAt: number;
+    }>;
+    generateMockToken: (email: string) => string;
+    generateOTP: () => string;
+    getMockApiKeyValidationResponse: (apiKey: string, isValid: boolean) => {
+        success: boolean;
+        data: {
+            _id: string;
+            created_at: string;
+            updated_at: string;
+            status: boolean;
+            api_key_status: "active" | "inactive";
+        };
+        message: string;
+        status: number;
+        timestamp: string;
+    };
+    getMockLogin2FAResponse: (email: string) => {
+        status: "otp_sent";
+        delivery: "email";
+        message: string;
+    };
+    getMockVerifyOTPResponse: (email: string) => {
+        data: {
+            _id: string;
+            created_at: string;
+            updated_at: string;
+            access_token: string;
+            token_type: "bearer";
+            expires_in: number;
+        };
+    };
+    findMockUser: (email: string) => {
+        email: string;
+        name: string;
+        otp: string;
+    };
+    isValidMockApiKey: (apiKey: string) => boolean;
+    storeOTP: (email: string, otp: string) => void;
+    verifyStoredOTP: (email: string, otp: string) => boolean;
+};
+export default _default;

package/dist/services/queries/hooks.d.ts

@@ -0,0 +1,64 @@
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import type { User, LoginCredentials, LoginResponse, CarrierSearchParams, CarrierSearchResult, CallLog, CallDetails, ChatMessage, Conversation } from '../types/api';
+import type { SearchFormData, CarrierSearchResponse, WorkflowStatusResponse } from '../../types/carrier';
+import type { DeleteWorkflowResponse } from '../../types/searchHistory';
+import type { EmailLead, EmailConversation } from '../../types/email';
+export declare const useAuth: () => import("@tanstack/react-query").UseQueryResult<User, Error>;
+export declare const useLogin: (options?: UseMutationOptions<LoginResponse, Error, LoginCredentials>) => import("@tanstack/react-query").UseMutationResult<LoginResponse, Error, LoginCredentials, unknown>;
+export declare const useLogout: (options?: UseMutationOptions<void, Error, void>) => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+export declare const useCarrierSearch: (params: CarrierSearchParams, options?: UseQueryOptions<CarrierSearchResult[], Error>) => import("@tanstack/react-query").UseQueryResult<CarrierSearchResult[], Error>;
+export declare const useCarrierDetails: (carrierId: string, options?: UseQueryOptions<CarrierSearchResult, Error>) => import("@tanstack/react-query").UseQueryResult<CarrierSearchResult, Error>;
+export declare const useCarrierSearchMutation: (options?: UseMutationOptions<CarrierSearchResponse, Error, SearchFormData>) => import("@tanstack/react-query").UseMutationResult<CarrierSearchResponse, Error, SearchFormData, unknown>;
+export declare const useCallLogs: (filters?: Record<string, any>, options?: UseQueryOptions<CallLog[], Error>) => import("@tanstack/react-query").UseQueryResult<CallLog[], Error>;
+export declare const useCallDetails: (callId: string, options?: UseQueryOptions<CallDetails, Error>) => import("@tanstack/react-query").UseQueryResult<CallDetails, Error>;
+export declare const useCallQueue: (options?: UseQueryOptions<CallLog[], Error>) => import("@tanstack/react-query").UseQueryResult<CallLog[], Error>;
+export declare const useChatMessages: (conversationId: string, options?: UseQueryOptions<ChatMessage[], Error>) => import("@tanstack/react-query").UseQueryResult<ChatMessage[], Error>;
+export declare const useSendMessage: (conversationId: string, options?: UseMutationOptions<ChatMessage, Error, {
+    content: string;
+    type?: string;
+}>) => import("@tanstack/react-query").UseMutationResult<ChatMessage, Error, {
+    content: string;
+    type?: string;
+}, unknown>;
+export declare const useChatHistory: (options?: UseQueryOptions<Conversation[], Error>) => import("@tanstack/react-query").UseQueryResult<Conversation[], Error>;
+export declare const useInfiniteList: <T>(queryKey: readonly unknown[], fetchFn: (pageParam: number) => Promise<{
+    data: T[];
+    nextPage?: number;
+}>, options?: any) => import("@tanstack/react-query").DefinedUseQueryResult<unknown, Error>;
+export declare const usePrefetchQueries: () => {
+    prefetchAuth: () => void;
+    prefetchCallQueue: () => void;
+    prefetchChatHistory: () => void;
+};
+export declare const useWorkflowList: () => {
+    fetchWorkflowPage: (page: number) => Promise<{
+        data: {
+            id: string;
+            title: string;
+            origin: string;
+            destination: string;
+            cargoType: string;
+            weight: number;
+            volume: number;
+            pickupDate: string;
+            deliveryDate: string;
+            status: "failed" | "pending" | "processing" | "completed";
+            totalCarriers: number;
+            createdAt: Date;
+            completedAt: Date;
+            workflowId: string;
+        }[];
+        hasMore: boolean;
+        total: number;
+    }>;
+};
+/**
+ * Hook for deleting a workflow with optimistic updates
+ */
+export declare const useDeleteWorkflow: (options?: UseMutationOptions<DeleteWorkflowResponse, Error, string>) => import("@tanstack/react-query").UseMutationResult<DeleteWorkflowResponse, Error, string, unknown>;
+/**
+ * Hook for fetching workflow status and results
+ */
+export declare const useWorkflowStatus: (workflowId: string, options?: UseQueryOptions<WorkflowStatusResponse, Error>) => import("@tanstack/react-query").UseQueryResult<WorkflowStatusResponse, Error>;
+export declare const useEmailLeads: (filters?: Record<string, any>, options?: UseQueryOptions<EmailLead[], Error>) => import("@tanstack/react-query").UseQueryResult<EmailLead[], Error>;
+export declare const useEmailConversation: (leadId: string, options?: UseQueryOptions<EmailConversation, Error>) => import("@tanstack/react-query").UseQueryResult<EmailConversation, Error>;

package/dist/services/queries/mutations.d.ts

@@ -0,0 +1,33 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { User, CarrierSearchResult, CallLog, CreateCallRequest, UpdateCallRequest } from '../types/api';
+interface UpdateProfileContext {
+    previousUser?: User;
+}
+interface UpdateCallContext {
+    previousCall: CallLog;
+}
+export declare const useUpdateProfile: (options?: UseMutationOptions<User, Error, Partial<User>, UpdateProfileContext>) => import("@tanstack/react-query").UseMutationResult<User, Error, Partial<User>, UpdateProfileContext>;
+export declare const useCreateCall: (options?: UseMutationOptions<CallLog, Error, CreateCallRequest>) => import("@tanstack/react-query").UseMutationResult<any, Error, CreateCallRequest, unknown>;
+export declare const useUpdateCall: (options?: UseMutationOptions<CallLog, Error, {
+    id: string;
+    data: UpdateCallRequest;
+}, UpdateCallContext>) => import("@tanstack/react-query").UseMutationResult<any, Error, {
+    id: string;
+    data: UpdateCallRequest;
+}, {
+    previousCall: CallLog;
+}>;
+export declare const useDeleteCall: (options?: UseMutationOptions<void, Error, string>) => import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare const useSaveCarrierSearch: (options?: UseMutationOptions<CarrierSearchResult[], Error, any>) => import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+export declare const useBulkUpdateCalls: (options?: UseMutationOptions<CallLog[], Error, {
+    ids: string[];
+    data: Partial<CallLog>;
+}>) => import("@tanstack/react-query").UseMutationResult<any, Error, {
+    ids: string[];
+    data: Partial<CallLog>;
+}, unknown>;
+export declare const useOptimisticUpdate: <T>(queryKey: readonly unknown[]) => {
+    updateOptimistically: (updater: (old: T | undefined) => T) => void;
+    revertOptimisticUpdate: (previousData: T) => void;
+};
+export {};

package/dist/services/queries/queryClient.d.ts

@@ -0,0 +1,59 @@
+import { QueryClient } from '@tanstack/react-query';
+export declare const queryClient: QueryClient;
+export declare const queryKeys: {
+    readonly auth: {
+        readonly me: () => readonly ["auth", "me"];
+        readonly permissions: () => readonly ["auth", "permissions"];
+    };
+    readonly users: {
+        readonly all: () => readonly ["users"];
+        readonly lists: () => readonly ["users", "list"];
+        readonly list: (filters: Record<string, any>) => readonly ["users", "list", Record<string, any>];
+        readonly details: () => readonly ["users", "detail"];
+        readonly detail: (id: string) => readonly ["users", "detail", string];
+    };
+    readonly carriers: {
+        readonly all: () => readonly ["carriers"];
+        readonly lists: () => readonly ["carriers", "list"];
+        readonly list: (filters: Record<string, any>) => readonly ["carriers", "list", Record<string, any>];
+        readonly details: () => readonly ["carriers", "detail"];
+        readonly detail: (id: string) => readonly ["carriers", "detail", string];
+        readonly search: (params: Record<string, any>) => readonly ["carriers", "search", Record<string, any>];
+    };
+    readonly calls: {
+        readonly all: () => readonly ["calls"];
+        readonly lists: () => readonly ["calls", "list"];
+        readonly list: (filters: Record<string, any>) => readonly ["calls", "list", Record<string, any>];
+        readonly details: () => readonly ["calls", "detail"];
+        readonly detail: (id: string) => readonly ["calls", "detail", string];
+        readonly logs: () => readonly ["calls", "logs"];
+        readonly queue: () => readonly ["calls", "queue"];
+    };
+    readonly chat: {
+        readonly all: () => readonly ["chat"];
+        readonly conversations: () => readonly ["chat", "conversations"];
+        readonly conversation: (id: string) => readonly ["chat", "conversations", string];
+        readonly messages: (conversationId: string) => readonly ["chat", "conversations", string, "messages"];
+        readonly history: () => readonly ["chat", "history"];
+    };
+    readonly emails: {
+        readonly all: () => readonly ["emails"];
+        readonly leads: () => readonly ["emails", "leads"];
+        readonly list: (filters: Record<string, any>) => readonly ["emails", "leads", Record<string, any>];
+        readonly details: () => readonly ["emails", "detail"];
+        readonly detail: (id: string) => readonly ["emails", "detail", string];
+    };
+};
+export declare const invalidateQueries: {
+    auth: () => Promise<void>;
+    users: () => Promise<void>;
+    carriers: () => Promise<void>;
+    calls: () => Promise<void>;
+    chat: () => Promise<void>;
+    all: () => Promise<void>;
+};
+export declare const prefetchQueries: {
+    userProfile: () => Promise<void>;
+    callQueue: () => Promise<void>;
+};
+export declare const handleQueryError: (error: any) => void;