@pol-studios/powersync 1.0.0

package/dist/provider/index.d.ts

@@ -0,0 +1,873 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { QueryClient } from '@tanstack/react-query';
+import { A as AbstractPowerSyncDatabase, a as SyncStatus, C as CrudEntry, S as SyncMode, F as FailedTransaction, h as CompletedTransaction, b as ConnectionHealth, e as SyncMetrics, D as DownloadProgress, E as EntitySyncState, f as SyncError } from '../types-afHtE1U_.js';
+import { PlatformAdapter } from '../platform/index.js';
+import { C as ConnectorConfig, S as SupabaseConnector } from '../supabase-connector-D14-kl5v.js';
+import { AttachmentQueueConfig, AttachmentQueue } from '../attachments/index.js';
+import * as react from 'react';
+import react__default from 'react';
+import { c as SyncControlActions } from '../types-Cd7RhNqf.js';
+
+/**
+ * Provider Types for @pol-studios/powersync
+ *
+ * Defines configuration and context interfaces for the PowerSyncProvider.
+ */
+
+/**
+ * Main configuration for PowerSyncProvider.
+ *
+ * @template TSchema - The PowerSync schema type
+ *
+ * @example
+ * ```typescript
+ * const config: PowerSyncConfig<AppSchema> = {
+ *   platform: createNativePlatformAdapter(logger),
+ *   schema: AppSchema,
+ *   powerSyncUrl: 'https://your-powersync-instance.com',
+ *   supabaseClient: supabase,
+ *   dbFilename: 'myapp.db',
+ *   sync: {
+ *     autoConnect: true,
+ *   },
+ * };
+ * ```
+ */
+interface PowerSyncConfig<TSchema = unknown> {
+    /**
+     * Platform adapter for platform-specific operations.
+     * Use createNativePlatformAdapter() for React Native or createWebPlatformAdapter() for Web.
+     */
+    platform: PlatformAdapter;
+    /**
+     * PowerSync schema definition.
+     * This defines the tables and their structure for the local database.
+     */
+    schema: TSchema;
+    /**
+     * PowerSync service URL.
+     * @example "https://your-instance.powersync.journeyapps.com"
+     */
+    powerSyncUrl: string;
+    /**
+     * Supabase client instance.
+     * Used for authentication and as the backend for CRUD uploads.
+     */
+    supabaseClient: SupabaseClient;
+    /**
+     * Optional: TanStack Query client for cache invalidation.
+     * If provided, will invalidate queries when sync completes.
+     */
+    queryClient?: QueryClient;
+    /**
+     * Optional: Database filename.
+     * @default "powersync.db"
+     */
+    dbFilename?: string;
+    /**
+     * Optional: Connector configuration for custom CRUD handling.
+     */
+    connector?: ConnectorConfig;
+    /**
+     * Optional: Attachment queue configuration for offline file caching.
+     */
+    attachments?: AttachmentQueueConfig;
+    /**
+     * Optional: Sync behavior configuration.
+     */
+    sync?: SyncConfig;
+}
+/**
+ * Sync behavior configuration.
+ */
+interface SyncConfig {
+    /**
+     * Automatically connect when the provider mounts and there's an authenticated session.
+     * @default true
+     */
+    autoConnect?: boolean;
+    /**
+     * Sync interval for periodic sync checks (in milliseconds).
+     * Set to 0 to disable periodic sync.
+     * @default 0 (disabled)
+     */
+    syncInterval?: number;
+    /**
+     * Enable health monitoring.
+     * @default true
+     */
+    enableHealthMonitoring?: boolean;
+    /**
+     * Enable metrics collection.
+     * @default true
+     */
+    enableMetrics?: boolean;
+}
+/**
+ * Value provided by the main PowerSyncContext.
+ *
+ * @template TSchema - The PowerSync schema type
+ */
+interface PowerSyncContextValue<TSchema = unknown> {
+    /**
+     * The PowerSync database instance.
+     * Will be null if not initialized or if initialization failed.
+     */
+    db: AbstractPowerSyncDatabase | null;
+    /**
+     * The Supabase connector instance.
+     * Will be null if not initialized.
+     */
+    connector: SupabaseConnector | null;
+    /**
+     * The attachment queue instance.
+     * Will be null if attachments are not configured or not initialized.
+     */
+    attachmentQueue: AttachmentQueue | null;
+    /**
+     * Whether the PowerSync database is ready for use.
+     */
+    isReady: boolean;
+    /**
+     * Whether the provider is currently initializing.
+     */
+    isInitializing: boolean;
+    /**
+     * Error that occurred during initialization, if any.
+     */
+    error: Error | null;
+    /**
+     * The schema used for this database.
+     */
+    schema: TSchema;
+    /**
+     * The platform adapter instance.
+     */
+    platform: PlatformAdapter;
+}
+/**
+ * Value provided by SyncStatusContext.
+ */
+interface SyncStatusContextValue {
+    /**
+     * Current sync status.
+     */
+    status: SyncStatus;
+    /**
+     * Pending mutations waiting to be uploaded.
+     */
+    pendingMutations: CrudEntry[];
+    /**
+     * Number of pending mutations.
+     */
+    pendingCount: number;
+    /**
+     * Whether data is currently being uploaded to the server.
+     * This is the authoritative source for upload activity.
+     */
+    isUploading: boolean;
+    /**
+     * Whether data is currently being downloaded from the server.
+     * This is the authoritative source for download activity.
+     */
+    isDownloading: boolean;
+    /**
+     * Whether sync is currently paused (offline mode).
+     */
+    isPaused: boolean;
+    /**
+     * Current sync mode: 'push-pull' (full sync), 'pull-only' (download only), or 'offline' (no sync).
+     */
+    syncMode: SyncMode;
+    /**
+     * Timestamp of the last successful sync.
+     */
+    lastSyncedAt: Date | null;
+    /**
+     * Error that occurred during connection, if any.
+     */
+    connectionError?: Error | null;
+    /**
+     * Failed transactions that need attention.
+     */
+    failedTransactions: FailedTransaction[];
+    /**
+     * Whether there are any upload errors.
+     */
+    hasUploadErrors: boolean;
+    /**
+     * Count of permanent errors that need user action.
+     */
+    permanentErrorCount: number;
+    /**
+     * Clear a specific failure by its ID.
+     */
+    clearFailure: (failureId: string) => void;
+    /**
+     * Clear all failures.
+     */
+    clearAllFailures: () => void;
+    /**
+     * Completed transactions history.
+     */
+    completedTransactions: CompletedTransaction[];
+    /**
+     * Clear the completed transaction history.
+     */
+    clearCompletedHistory: () => void;
+    /**
+     * Set the sync mode.
+     * @param mode - The sync mode to set
+     */
+    setSyncMode: (mode: SyncMode) => Promise<void>;
+    /**
+     * Set the force next upload flag.
+     * When true, the next sync cycle will upload regardless of sync mode.
+     */
+    setForceNextUpload: (force: boolean) => void;
+    /**
+     * Discard a specific pending mutation by its client ID.
+     * Uses safe disconnect/reconnect pattern to avoid transaction conflicts.
+     * @throws Error if upload is in progress
+     */
+    discardPendingMutation: (clientId: number) => Promise<void>;
+    /**
+     * Discard all pending mutations.
+     * Uses safe disconnect/reconnect pattern to avoid transaction conflicts.
+     * @throws Error if upload is in progress
+     */
+    discardAllPendingMutations: () => Promise<void>;
+}
+/**
+ * Value provided by ConnectionHealthContext.
+ */
+interface ConnectionHealthContextValue {
+    /**
+     * Current connection health status.
+     */
+    health: ConnectionHealth;
+}
+/**
+ * Value provided by SyncMetricsContext.
+ */
+interface SyncMetricsContextValue {
+    /**
+     * Current sync metrics.
+     */
+    metrics: SyncMetrics;
+}
+/**
+ * Props for the PowerSyncProvider component.
+ *
+ * @template TSchema - The PowerSync schema type
+ */
+interface PowerSyncProviderProps<TSchema = unknown> {
+    /**
+     * PowerSync configuration.
+     */
+    config: PowerSyncConfig<TSchema>;
+    /**
+     * Child components to render.
+     */
+    children: React.ReactNode;
+    /**
+     * Called when the database is initialized and ready.
+     */
+    onReady?: () => void;
+    /**
+     * Called when an error occurs during initialization.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when sync status changes.
+     */
+    onSyncStatusChange?: (status: SyncStatus) => void;
+}
+/**
+ * Default sync status.
+ */
+declare const DEFAULT_SYNC_STATUS: SyncStatus;
+/**
+ * Default connection health.
+ */
+declare const DEFAULT_CONNECTION_HEALTH: ConnectionHealth;
+/**
+ * Default sync metrics.
+ */
+declare const DEFAULT_SYNC_METRICS: SyncMetrics;
+/**
+ * Default sync configuration.
+ */
+declare const DEFAULT_SYNC_CONFIG: Required<SyncConfig>;
+
+/**
+ * Main context for PowerSync database instance and related state.
+ *
+ * Provides access to:
+ * - PowerSync database instance
+ * - SupabaseConnector instance
+ * - AttachmentQueue instance (if configured)
+ * - Initialization state
+ *
+ * @example
+ * ```typescript
+ * const { db, isReady, error } = useContext(PowerSyncContext);
+ * ```
+ */
+declare const PowerSyncContext: react.Context<PowerSyncContextValue<unknown>>;
+/**
+ * Context for sync status updates.
+ *
+ * Provides access to:
+ * - Current sync status (connected, syncing, etc.)
+ * - Pending mutations count
+ * - Paused state
+ * - Last synced timestamp
+ *
+ * @example
+ * ```typescript
+ * const { status, pendingCount, isPaused } = useContext(SyncStatusContext);
+ * ```
+ */
+declare const SyncStatusContext: react.Context<SyncStatusContextValue>;
+/**
+ * Context for connection health monitoring.
+ *
+ * Provides access to:
+ * - Health status (healthy, degraded, disconnected)
+ * - Latency measurements
+ * - Health check timestamps
+ * - Failure counts
+ *
+ * @example
+ * ```typescript
+ * const { health } = useContext(ConnectionHealthContext);
+ * if (health.status === 'degraded') {
+ *   showWarning('Connection is slow');
+ * }
+ * ```
+ */
+declare const ConnectionHealthContext: react.Context<ConnectionHealthContextValue>;
+/**
+ * Context for sync metrics and statistics.
+ *
+ * Provides access to:
+ * - Sync operation counts
+ * - Sync durations
+ * - Data transfer amounts
+ * - Error tracking
+ *
+ * @example
+ * ```typescript
+ * const { metrics } = useContext(SyncMetricsContext);
+ * console.log(`Total syncs: ${metrics.totalSyncs}`);
+ * ```
+ */
+declare const SyncMetricsContext: react.Context<SyncMetricsContextValue>;
+/**
+ * Context for the attachment queue (if configured).
+ *
+ * Provides direct access to the AttachmentQueue instance for:
+ * - Checking attachment sync stats
+ * - Pausing/resuming downloads
+ * - Getting local URIs for attachments
+ *
+ * @example
+ * ```typescript
+ * const attachmentQueue = useContext(AttachmentQueueContext);
+ * if (attachmentQueue) {
+ *   const stats = await attachmentQueue.getStats();
+ *   console.log(`Downloaded: ${stats.syncedCount}/${stats.totalExpected}`);
+ * }
+ * ```
+ */
+declare const AttachmentQueueContext: react.Context<AttachmentQueue>;
+
+/**
+ * PowerSyncProvider Component for @pol-studios/powersync
+ *
+ * Main provider component that initializes and manages the PowerSync database,
+ * connector, attachment queue, and all monitoring services.
+ */
+
+/**
+ * PowerSyncProvider initializes and manages the PowerSync database and related services.
+ *
+ * Features:
+ * - Initializes PowerSync database using platform adapter
+ * - Creates and manages SupabaseConnector
+ * - Connects/disconnects based on auth state
+ * - Tracks sync status and connection health
+ * - Optionally initializes AttachmentQueue
+ * - Provides all contexts to children
+ * - Handles cleanup on unmount
+ *
+ * @example
+ * ```tsx
+ * import { PowerSyncProvider, usePowerSync, useSyncStatus } from '@pol-studios/powersync';
+ *
+ * function App() {
+ *   return (
+ *     <PowerSyncProvider
+ *       config={{
+ *         platform: createNativePlatformAdapter(logger),
+ *         schema: AppSchema,
+ *         powerSyncUrl: 'https://your-powersync.com',
+ *         supabaseClient: supabase,
+ *       }}
+ *       onReady={() => console.log('PowerSync ready!')}
+ *       onError={(err) => console.error('PowerSync error:', err)}
+ *     >
+ *       <MainApp />
+ *     </PowerSyncProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function PowerSyncProvider<TSchema = unknown>({ config, children, onReady, onError, onSyncStatusChange, }: PowerSyncProviderProps<TSchema>): react__default.ReactElement;
+
+/**
+ * Hook to access the PowerSync database and related services.
+ *
+ * @returns PowerSync context value with database, connector, and state
+ * @throws Error if used outside of PowerSyncProvider
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { db, isReady, error } = usePowerSync();
+ *
+ *   if (!isReady) return <LoadingSpinner />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   // Use db for queries
+ *   const users = await db.getAll('SELECT * FROM users');
+ * }
+ * ```
+ */
+declare function usePowerSync<TSchema = unknown>(): PowerSyncContextValue<TSchema>;
+/**
+ * Hook to access the current sync status.
+ *
+ * @returns Sync status with connection state, pending uploads, and progress
+ * @throws Error if used outside of PowerSyncProvider
+ *
+ * @example
+ * ```typescript
+ * function SyncIndicator() {
+ *   const { status, pendingCount, isPaused } = useSyncStatus();
+ *
+ *   if (status.downloading) {
+ *     const { current, target, percentage } = status.downloadProgress ?? {};
+ *     return <Progress value={percentage} label={`${current}/${target}`} />;
+ *   }
+ *
+ *   if (pendingCount > 0) {
+ *     return <Badge>{pendingCount} pending uploads</Badge>;
+ *   }
+ *
+ *   return <Text>Synced</Text>;
+ * }
+ * ```
+ */
+declare function useSyncStatus(): SyncStatusContextValue;
+/**
+ * Hook to control sync operations.
+ *
+ * @returns Actions for triggering, pausing, and resuming sync
+ *
+ * @example
+ * ```typescript
+ * function SyncControls() {
+ *   const { triggerSync, syncNow, pause, resume, disconnect, setSyncMode } = useSyncControl();
+ *   const { isPaused, syncMode } = useSyncStatus();
+ *
+ *   return (
+ *     <View>
+ *       <Button onPress={syncNow}>Sync Now</Button>
+ *       {isPaused ? (
+ *         <Button onPress={resume}>Resume</Button>
+ *       ) : (
+ *         <Button onPress={pause}>Pause</Button>
+ *       )}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncControl(): SyncControlActions;
+/**
+ * Hook to get and set the current sync mode.
+ *
+ * @returns Object with current mode, setter, and capability flags
+ *
+ * @example
+ * ```typescript
+ * function SyncModeSelector() {
+ *   const { mode, setMode, canUpload, canDownload } = useSyncMode();
+ *
+ *   return (
+ *     <View>
+ *       <Text>Current mode: {mode}</Text>
+ *       <Text>Can upload: {canUpload ? 'Yes' : 'No'}</Text>
+ *       <Button onPress={() => setMode('pull-only')}>Download Only</Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncMode(): {
+    mode: SyncMode;
+    setMode: (mode: SyncMode) => Promise<void>;
+    canUpload: boolean;
+    canDownload: boolean;
+};
+/**
+ * Hook to access connection health status.
+ *
+ * @returns Current connection health with latency and failure tracking
+ * @throws Error if used outside of PowerSyncProvider
+ *
+ * @example
+ * ```typescript
+ * function ConnectionIndicator() {
+ *   const health = useConnectionHealth();
+ *
+ *   const statusColor = {
+ *     healthy: 'green',
+ *     degraded: 'yellow',
+ *     disconnected: 'red',
+ *   }[health.status];
+ *
+ *   return (
+ *     <View>
+ *       <StatusDot color={statusColor} />
+ *       {health.latency && <Text>{health.latency}ms</Text>}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useConnectionHealth(): ConnectionHealth;
+/**
+ * Hook to access sync metrics.
+ *
+ * @returns Sync metrics including success rates, timing, and data transfer
+ * @throws Error if used outside of PowerSyncProvider
+ *
+ * @example
+ * ```typescript
+ * function SyncStats() {
+ *   const metrics = useSyncMetrics();
+ *
+ *   const successRate = metrics.totalSyncs > 0
+ *     ? (metrics.successfulSyncs / metrics.totalSyncs * 100).toFixed(1)
+ *     : 100;
+ *
+ *   return (
+ *     <View>
+ *       <Text>Total syncs: {metrics.totalSyncs}</Text>
+ *       <Text>Success rate: {successRate}%</Text>
+ *       <Text>Avg duration: {metrics.averageSyncDuration ?? 'N/A'}ms</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncMetrics(): SyncMetrics;
+/**
+ * Hook to access the attachment queue (if configured).
+ *
+ * @returns AttachmentQueue instance or null if not configured
+ *
+ * @example
+ * ```typescript
+ * function PhotoStats() {
+ *   const attachmentQueue = useAttachmentQueue();
+ *   const [stats, setStats] = useState(null);
+ *
+ *   useEffect(() => {
+ *     if (!attachmentQueue) return;
+ *
+ *     return attachmentQueue.onProgress((newStats) => {
+ *       setStats(newStats);
+ *     });
+ *   }, [attachmentQueue]);
+ *
+ *   if (!stats) return null;
+ *
+ *   return (
+ *     <View>
+ *       <Text>Photos: {stats.syncedCount}/{stats.totalExpected}</Text>
+ *       <Text>Cache used: {formatBytes(stats.syncedSize)}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useAttachmentQueue(): AttachmentQueue | null;
+/**
+ * Hook to get the PowerSync database instance.
+ * Throws if not ready.
+ *
+ * @returns The PowerSync database instance
+ * @throws Error if not initialized or used outside of PowerSyncProvider
+ *
+ * @example
+ * ```typescript
+ * function UserList() {
+ *   const db = useDatabase();
+ *   const [users, setUsers] = useState([]);
+ *
+ *   useEffect(() => {
+ *     db.getAll('SELECT * FROM users').then(setUsers);
+ *   }, [db]);
+ *
+ *   return <FlatList data={users} />;
+ * }
+ * ```
+ */
+declare function useDatabase(): AbstractPowerSyncDatabase;
+/**
+ * Hook to access the platform adapter.
+ *
+ * @returns The platform adapter instance
+ *
+ * @example
+ * ```typescript
+ * function FileViewer({ filePath }) {
+ *   const { platform } = usePowerSync();
+ *
+ *   const handleOpen = async () => {
+ *     const content = await platform.fileSystem.readFile(filePath);
+ *     // Process content...
+ *   };
+ *
+ *   return <Button onPress={handleOpen}>Open File</Button>;
+ * }
+ * ```
+ */
+declare function usePlatform(): PlatformAdapter;
+/**
+ * Hook to track online/offline status using the platform's network adapter.
+ *
+ * @returns Whether the device is currently connected to the internet
+ *
+ * @example
+ * ```typescript
+ * function OfflineBanner() {
+ *   const isOnline = useOnlineStatus();
+ *
+ *   if (isOnline) return null;
+ *
+ *   return <Banner type="warning">You are offline</Banner>;
+ * }
+ * ```
+ */
+declare function useOnlineStatus(): boolean;
+/**
+ * Hook to get pending mutations that need to be uploaded.
+ *
+ * @returns Array of pending CRUD entries and count
+ *
+ * @example
+ * ```typescript
+ * function PendingChanges() {
+ *   const { mutations, count } = usePendingMutations();
+ *
+ *   if (count === 0) return null;
+ *
+ *   return (
+ *     <View>
+ *       <Text>{count} changes pending upload</Text>
+ *       <FlatList
+ *         data={mutations}
+ *         renderItem={({ item }) => (
+ *           <Text>{item.op} on {item.table}</Text>
+ *         )}
+ *       />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function usePendingMutations(): {
+    mutations: CrudEntry[];
+    count: number;
+};
+/**
+ * Hook to check if sync is currently active.
+ *
+ * @returns Whether sync is currently in progress (uploading or downloading)
+ *
+ * @example
+ * ```typescript
+ * function SyncButton() {
+ *   const isSyncing = useIsSyncing();
+ *   const { triggerSync } = useSyncControl();
+ *
+ *   return (
+ *     <Button
+ *       onPress={triggerSync}
+ *       disabled={isSyncing}
+ *     >
+ *       {isSyncing ? 'Syncing...' : 'Sync Now'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useIsSyncing(): boolean;
+/**
+ * Hook to get download progress during sync.
+ *
+ * @returns Download progress or null if not downloading
+ *
+ * @example
+ * ```typescript
+ * function DownloadProgress() {
+ *   const progress = useDownloadProgress();
+ *
+ *   if (!progress) return null;
+ *
+ *   return (
+ *     <ProgressBar
+ *       value={progress.percentage}
+ *       label={`${progress.current}/${progress.target} operations`}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useDownloadProgress(): DownloadProgress;
+/**
+ * Return type for useEntitySyncStatus hook.
+ */
+interface EntitySyncStatusResult {
+    /** Current sync state for this entity */
+    state: EntitySyncState;
+    /** Error details if state is 'error' */
+    error: SyncError | null;
+    /** Number of pending operations for this entity */
+    pendingOperations: number;
+    /** The failed transaction if any */
+    failedTransaction: FailedTransaction | null;
+    /** Dismiss the failure (remove from tracking) */
+    dismiss: () => void;
+}
+/**
+ * Hook to get sync status for a specific entity.
+ *
+ * Combines local mutation state (from pending mutations) with
+ * failure state to provide a unified status for UI.
+ *
+ * @param entityId - The entity ID to check status for
+ * @returns Unified sync state and actions
+ *
+ * @example
+ * ```typescript
+ * function EquipmentHeader({ unitId }) {
+ *   const { state, error, dismiss } = useEntitySyncStatus(unitId);
+ *
+ *   const borderColor = {
+ *     idle: 'transparent',
+ *     saving: 'orange',
+ *     syncing: 'amber',
+ *     synced: 'green',
+ *     error: 'red',
+ *   }[state];
+ * }
+ * ```
+ */
+declare function useEntitySyncStatus(entityId: string | undefined): EntitySyncStatusResult;
+/**
+ * Return type for useUploadStatus hook.
+ */
+interface UploadStatusResult {
+    /** Number of operations waiting to upload */
+    pendingCount: number;
+    /** Number of failed transactions */
+    failedCount: number;
+    /** Number of permanent failures needing user action */
+    permanentFailureCount: number;
+    /** Whether there are any errors */
+    hasErrors: boolean;
+    /** Whether there are permanent errors needing attention */
+    hasPermanentErrors: boolean;
+    /** All failed transactions */
+    failedTransactions: FailedTransaction[];
+    /** Trigger sync retry (reconnect) */
+    retryAll: () => Promise<void>;
+    /** Dismiss all failures */
+    dismissAll: () => void;
+}
+/**
+ * Hook to get overall upload status across all entities.
+ *
+ * @returns Upload status with counts and actions
+ *
+ * @example
+ * ```typescript
+ * function SyncStatusBar() {
+ *   const { pendingCount, failedCount, hasPermanentErrors, retryAll } = useUploadStatus();
+ *
+ *   if (hasPermanentErrors) {
+ *     return <Banner onRetry={retryAll}>
+ *       {failedCount} changes failed to sync
+ *     </Banner>;
+ *   }
+ * }
+ * ```
+ */
+declare function useUploadStatus(): UploadStatusResult;
+/**
+ * Return type for useSyncActivity hook.
+ */
+interface SyncActivityResult {
+    /** Pending CRUD entries waiting to be synced */
+    pending: CrudEntry[];
+    /** Failed transactions that need attention */
+    failed: FailedTransaction[];
+    /** Recently completed transactions */
+    completed: CompletedTransaction[];
+    /** Counts summary */
+    counts: {
+        pending: number;
+        failed: number;
+        completed: number;
+    };
+    /** Whether there is any sync activity to show (pending or failed) */
+    hasActivity: boolean;
+    /** Retry all failed transactions */
+    retryAll: () => Promise<void>;
+    /** Dismiss a specific failure */
+    dismissFailure: (failureId: string) => void;
+    /** Clear all completed transactions from the list */
+    clearCompleted: () => void;
+}
+/**
+ * Hook to get comprehensive sync activity including pending, failed, and completed transactions.
+ *
+ * Uses the provider's completed transaction tracking via the status tracker.
+ *
+ * @returns Sync activity with all transaction states and actions
+ *
+ * @example
+ * ```typescript
+ * function SyncActivityBanner() {
+ *   const { pending, failed, completed, counts, hasActivity, retryAll, clearCompleted } = useSyncActivity();
+ *
+ *   if (!hasActivity && completed.length === 0) return null;
+ *
+ *   return (
+ *     <View>
+ *       <Text>{counts.pending} syncing, {counts.failed} failed</Text>
+ *       {failed.length > 0 && <Button onPress={retryAll}>Retry All</Button>}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncActivity(): SyncActivityResult;
+
+export { AttachmentQueueContext, ConnectionHealthContext, type ConnectionHealthContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, type EntitySyncStatusResult, type PowerSyncConfig, PowerSyncContext, type PowerSyncContextValue, PowerSyncProvider, type PowerSyncProviderProps, type SyncActivityResult, type SyncConfig, SyncMetricsContext, type SyncMetricsContextValue, SyncStatusContext, type SyncStatusContextValue, type UploadStatusResult, useAttachmentQueue, useConnectionHealth, useDatabase, useDownloadProgress, useEntitySyncStatus, useIsSyncing, useOnlineStatus, usePendingMutations, usePlatform, usePowerSync, useSyncActivity, useSyncControl, useSyncMetrics, useSyncMode, useSyncStatus, useUploadStatus };