@pol-studios/powersync 1.0.25 → 1.0.32

package/dist/provider/index.d.ts

@@ -1,17 +1,19 @@
 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-CDqWh56B.js';
+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, U as UploadBlockReason } from '../types-B9MptP7E.js';
 import { PlatformAdapter } from '../platform/index.js';
-import { a as ConnectorConfig, i as ConflictBus } from '../types-DiBvmGEi.js';
-import { f as AttachmentConfig, P as PolAttachmentQueue, A as AttachmentSourceConfig, F as AttachmentRecord, C as CompressionConfig, j as DownloadConfig } from '../pol-attachment-queue-BE2HU3Us.js';
-import { S as SupabaseConnector } from '../supabase-connector-D2oIl2t8.js';
+import { a as ConnectorConfig, i as ConflictBus, h as UploadErrorMiddleware } from '../types-DqJnP50o.js';
+import { d as AttachmentConfig, c as AttachmentSourceConfig, z as AttachmentRecord, f as CompressionConfig, i as DownloadConfig } from '../types-JCEhw2Lf.js';
+import { P as PolAttachmentQueue } from '../pol-attachment-queue-DqBvLAEY.js';
+import { S as SupabaseConnector } from '../supabase-connector-HMxBA9Kg.js';
 import * as react from 'react';
 import react__default, { ReactNode } from 'react';
 import { Schema } from '@powersync/react-native';
-import { a as StorageBackend } from '../types-D0WcHrq6.js';
-import { h as BackgroundSyncSystem, c as SyncControlActions } from '../background-sync-ChCXW-EV.js';
-import '@powersync/attachments';
+import { a as StorageBackend } from '../types-CGMibJKD.js';
+import { h as BackgroundSyncSystem, c as SyncControlActions } from '../background-sync-BujnI3IR.js';
+import { a as ProcessedPolConfig } from '../types-BhAEsJj-.js';
 import '@powersync/common';
+import '@powersync/attachments';
 
 /**
  * Provider Types for @pol-studios/powersync
@@ -79,8 +81,12 @@ interface PowerSyncConfig<TSchema = unknown> {
      * @example
      * ```typescript
      * attachments: {
-     *   source: { table: 'photos', idColumn: 'storage_path' },
-     *   remoteStorage: supabaseStorageAdapter,
+     *   source: { type: 'supabase-bucket', bucket: 'photos' },
+     *   watchPaths: (db, supabase, onUpdate) => {
+     *     db.watch('SELECT storage_path FROM photos', [], {
+     *       onResult: (r) => onUpdate(r.rows._array.map(x => x.storage_path)),
+     *     });
+     *   },
      * }
      * ```
      */
@@ -116,6 +122,26 @@ interface SyncConfig {
      */
     enableMetrics?: boolean;
 }
+/**
+ * Options for resetSync operation.
+ */
+interface ResetSyncOptions {
+    /**
+     * Clear downloaded attachments (photos, documents).
+     * @default true
+     */
+    clearAttachments?: boolean;
+    /**
+     * Clear React Query cache.
+     * @default true
+     */
+    clearQueryCache?: boolean;
+    /**
+     * Timeout for cache operations in milliseconds.
+     * @default 30000
+     */
+    timeout?: number;
+}
 /**
  * Value provided by the main PowerSyncContext.
  *
@@ -173,6 +199,23 @@ interface PowerSyncContextValue<TSchema = unknown> {
      * Use this to wire up conflict UI components.
      */
     conflictBus: ConflictBus;
+    /**
+     * Reset sync data by disconnecting and clearing synced data.
+     * Optionally clears React Query cache and attachment cache.
+     *
+     * @param options - Reset options
+     * @example
+     * ```typescript
+     * const { resetSync } = usePowerSync();
+     *
+     * await resetSync({
+     *   clearAttachments: true,  // Clear downloaded photos/documents
+     *   clearQueryCache: true,   // Clear React Query cache
+     *   timeout: 30000,          // Timeout for cache operations
+     * });
+     * ```
+     */
+    resetSync: (options?: ResetSyncOptions) => Promise<void>;
 }
 /**
  * Value provided by SyncStatusContext.
@@ -232,10 +275,6 @@ interface SyncStatusContextValue {
      * Clear a specific failure by its ID.
      */
     clearFailure: (failureId: string) => void;
-    /**
-     * Clear all failures.
-     */
-    clearAllFailures: () => void;
     /**
      * Completed transactions history.
      */
@@ -261,20 +300,31 @@ interface SyncStatusContextValue {
      */
     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
+     * Whether we're currently waiting for a retry after upload failure.
+     */
+    isWaitingForUploadRetry: boolean;
+    /**
+     * When the next retry will occur (null if not waiting).
      */
-    discardAllPendingMutations: () => Promise<void>;
+    nextUploadRetryAt: Date | null;
     /**
-     * Pause automatic retry of failed uploads.
-     * Useful when user is actively resolving conflicts.
+     * Whether the maximum retry attempts have been reached.
      */
-    pauseAutoRetry: () => void;
+    maxUploadRetriesReached: boolean;
     /**
-     * Resume automatic retry of failed uploads.
+     * Current retry attempt count.
      */
-    resumeAutoRetry: () => void;
+    uploadRetryCount: number;
+    /**
+     * Force a manual retry after max retries reached.
+     */
+    manualUploadRetry: () => Promise<void>;
+    /**
+     * Discard a specific failed entry by its ps_crud ID and reconnect.
+     * Use this when a single entry is causing upload failures.
+     * @param entryId - The ps_crud entry ID (clientId) to discard
+     */
+    discardFailedEntryAndReconnect: (entryId: number) => Promise<void>;
 }
 /**
  * Connection state - changes rarely (on connect/disconnect).
@@ -315,8 +365,6 @@ interface PendingMutationsContextValue {
     pendingCount: number;
     /** Discard a specific pending mutation by its client ID */
     discardPendingMutation: (clientId: number) => Promise<void>;
-    /** Discard all pending mutations */
-    discardAllPendingMutations: () => Promise<void>;
     /**
      * Add a pending mutation to the list.
      * Called by mutation hooks (useDbInsert, useDbUpdate, useDbDelete, useDbUpsert)
@@ -342,12 +390,6 @@ interface FailedTransactionsContextValue {
     permanentErrorCount: number;
     /** Clear a specific failure by its ID */
     clearFailure: (failureId: string) => void;
-    /** Clear all failures */
-    clearAllFailures: () => void;
-    /** Pause automatic retry of failed uploads */
-    pauseAutoRetry: () => void;
-    /** Resume automatic retry of failed uploads */
-    resumeAutoRetry: () => void;
     /**
      * Retry a specific failed transaction.
      *
@@ -405,6 +447,36 @@ interface SyncModeContextValue {
     setSyncMode: (mode: SyncMode) => Promise<void>;
     /** Set the force next upload flag */
     setForceNextUpload: (force: boolean) => void;
+    /**
+     * Whether we're currently waiting for a retry after upload failure.
+     * When true, PowerSync is disconnected and waiting for the backoff timer.
+     */
+    isWaitingForUploadRetry: boolean;
+    /**
+     * When the next retry will occur (null if not waiting).
+     * Use this to display a countdown to the user.
+     */
+    nextUploadRetryAt: Date | null;
+    /**
+     * Whether the maximum retry attempts have been reached.
+     * When true, the system won't automatically retry - user must intervene.
+     */
+    maxUploadRetriesReached: boolean;
+    /**
+     * Current retry attempt count (0 when no retries have occurred).
+     */
+    uploadRetryCount: number;
+    /**
+     * Force a manual retry after max retries reached.
+     * Resets retry state and attempts to reconnect.
+     */
+    manualUploadRetry: () => Promise<void>;
+    /**
+     * Discard a specific failed entry by its ps_crud ID and reconnect.
+     * Use this when a single entry is causing upload failures.
+     * @param entryId - The ps_crud entry ID (clientId) to discard
+     */
+    discardFailedEntryAndReconnect: (entryId: number) => Promise<void>;
 }
 /**
  * Value provided by ConnectionHealthContext.
@@ -693,7 +765,26 @@ interface PowerSyncSyncStatusSnapshot {
 }
 /**
  * Attachment configuration for OfflineDataProvider.
- * Uses the new 2-callback API (watchIds, skipDownload).
+ *
+ * @example
+ * ```typescript
+ * attachments: {
+ *   source: { type: 'supabase-bucket', bucket: 'photos', signed: true },
+ *   watchPaths: (db, supabase, onUpdate) => {
+ *     const abort = new AbortController();
+ *     db.watch(
+ *       // Filter directly in the query - only emit paths you want to download
+ *       `SELECT storagePath FROM photos
+ *        WHERE storagePath IS NOT NULL
+ *        AND storagePath NOT LIKE '%.mp4'`,
+ *       [],
+ *       { onResult: (r) => onUpdate(r.rows._array.map(x => x.storagePath)) },
+ *       { signal: abort.signal }
+ *     );
+ *     return () => abort.abort();
+ *   },
+ * }
+ * ```
  */
 interface OfflineDataAttachmentConfig extends AttachmentSourceConfig {
     /** Optional: callback when upload completes */
@@ -739,6 +830,8 @@ interface OfflineDataProviderConfig {
         conflictDetection?: {
             enabled: boolean;
         };
+        /** Upload error middleware chain for classifying and handling upload errors */
+        uploadErrorMiddleware?: UploadErrorMiddleware[];
     };
     /** Sync behavior configuration */
     sync?: {
@@ -754,8 +847,45 @@ interface OfflineDataProviderConfig {
  * Props for OfflineDataProvider
  */
 interface OfflineDataProviderProps {
-    /** Provider configuration */
-    config: OfflineDataProviderConfig;
+    /**
+     * Provider configuration (legacy).
+     * Use either `config` OR `polConfig`, not both.
+     */
+    config?: OfflineDataProviderConfig;
+    /**
+     * Unified configuration from `definePolConfig`.
+     * This is the recommended way to configure OfflineDataProvider.
+     *
+     * When using polConfig, you must also provide:
+     * - `supabaseClient`
+     * - `queryClient`
+     *
+     * @example
+     * ```tsx
+     * import { definePolConfig } from '@pol-studios/powersync/config';
+     *
+     * const polConfig = definePolConfig({ ... });
+     *
+     * <OfflineDataProvider
+     *   polConfig={polConfig}
+     *   supabaseClient={supabase}
+     *   queryClient={queryClient}
+     * >
+     *   <App />
+     * </OfflineDataProvider>
+     * ```
+     */
+    polConfig?: ProcessedPolConfig;
+    /**
+     * Supabase client instance.
+     * Required when using `polConfig`.
+     */
+    supabaseClient?: SupabaseClient;
+    /**
+     * React Query client.
+     * Required when using `polConfig`.
+     */
+    queryClient?: QueryClient;
     children: ReactNode;
     /**
      * DataLayer configuration for @pol-studios/db integration.
@@ -774,6 +904,37 @@ interface OfflineDataProviderProps {
     skipStorageQueueProvider?: boolean;
     /** Custom storage backend (overrides built-in Supabase adapter) */
     storageBackend?: StorageBackend;
+    /**
+     * Custom platform adapter (optional).
+     * Use this to provide custom logging or filesystem implementations.
+     * If not provided, a default native platform adapter is created.
+     */
+    platform?: PlatformAdapter;
+    /**
+     * Attachment callback overrides at React level.
+     * These override the callbacks defined in polConfig.attachments,
+     * allowing you to use React hooks or access component context.
+     *
+     * @example
+     * ```tsx
+     * const watchPaths = useCallback((db, supabase, onUpdate) => {
+     *   db.watch(
+     *     `SELECT storagePath FROM photos
+     *      WHERE storagePath IS NOT NULL
+     *      AND mediaType NOT LIKE 'video/%'`,
+     *     [],
+     *     { onResult: (r) => onUpdate(r.rows._array.map(x => x.storagePath)) }
+     *   );
+     *   return () => {};
+     * }, []);
+     *
+     * <OfflineDataProvider
+     *   polConfig={polConfig}
+     *   attachments={{ watchPaths }}
+     * >
+     * ```
+     */
+    attachments?: Partial<Pick<OfflineDataAttachmentConfig, 'watchPaths'>>;
     /** Custom error UI for initialization errors */
     renderInitError?: (error: Error, retry: () => void) => ReactNode;
     /** Custom error UI (alias for renderInitError) */
@@ -810,94 +971,6 @@ interface ProviderBridgeProps {
     onRemovePendingMutationReady: (remove: (id: string) => void) => void;
 }
 
-/**
- * OfflineDataProvider Component for @pol-studios/powersync
- *
- * Batteries-included offline data provider that combines:
- * - PowerSyncProvider for offline-first data sync
- * - DataLayerProvider integration from @pol-studios/db
- * - ConflictProvider for conflict resolution UI
- * - StorageQueueProvider for attachment queue access
- * - Background sync system setup
- * - Error recovery UI with retry capability
- * - Online-only mode fallback (no PowerSync URL)
- *
- * @example
- * ```tsx
- * <OfflineDataProvider
- *   config={{
- *     schema: AppSchema,
- *     supabaseClient: supabase,
- *     queryClient: queryClient,
- *     powerSyncUrl: env.powerSyncUrl,
- *     attachments: {
- *       bucket: 'my-bucket',
- *       watchIds: (db, onUpdate) => {
- *         db.watch('SELECT storagePath as id FROM photos', [], {
- *           onResult: (r) => onUpdate(r.rows._array.map(x => x.id)),
- *         });
- *       },
- *       skipDownload: async ({ ids }) => {
- *         // Return IDs to skip downloading (e.g., videos)
- *         return ids.filter(id => id.endsWith('.mp4'));
- *       },
- *     },
- *   }}
- *   dataLayer={{ config: dataLayerConfig }}
- *   renderInitError={(error, retry) => <MyErrorUI error={error} onRetry={retry} />}
- * >
- *   <App />
- * </OfflineDataProvider>
- * ```
- */
-
-/**
- * Batteries-included offline data provider.
- *
- * Combines PowerSyncProvider with error boundary, DataLayerProvider integration,
- * and sensible defaults for a complete offline-first data solution.
- *
- * Key features:
- * - Automatic PowerSync setup and initialization
- * - Integration with @pol-studios/db DataLayerProvider
- * - ConflictProvider and StorageQueueProvider wiring
- * - Background sync system support
- * - Error recovery UI with retry capability
- * - Online-only mode fallback when no PowerSync URL is provided
- *
- * @example
- * ```tsx
- * // Basic usage
- * <OfflineDataProvider
- *   config={{
- *     schema: AppSchema,
- *     supabaseClient: supabase,
- *     queryClient: queryClient,
- *     powerSyncUrl: process.env.EXPO_PUBLIC_POWERSYNC_URL,
- *   }}
- * >
- *   <App />
- * </OfflineDataProvider>
- *
- * // With DataLayer integration
- * <OfflineDataProvider
- *   config={{ ... }}
- *   dataLayer={{ config: dataLayerConfig }}
- * >
- *   <App />
- * </OfflineDataProvider>
- *
- * // With custom error UI
- * <OfflineDataProvider
- *   config={{ ... }}
- *   renderInitError={(error, retry) => <MyErrorUI error={error} onRetry={retry} />}
- * >
- *   <App />
- * </OfflineDataProvider>
- * ```
- */
-declare function OfflineDataProvider({ config, children, dataLayer, backgroundSync, skipConflictProvider, skipStorageQueueProvider, storageBackend, renderInitError, renderError, onReady, onError, onSyncStatusChange, onBackgroundSyncSystemReady: onBackgroundSyncSystemReadyProp, }: OfflineDataProviderProps): react__default.ReactElement;
-
 /**
  * ProviderBridge Component for @pol-studios/powersync
  *
@@ -1164,6 +1237,58 @@ declare function useSyncMode(): {
     canDownload: boolean;
     networkReachable: boolean;
 };
+/**
+ * Hook to access upload retry state for exponential backoff handling.
+ *
+ * When an upload fails, the provider disconnects and waits with exponential backoff
+ * before reconnecting. After 7 failed attempts (256s backoff), it stays disconnected
+ * and lets the user decide.
+ *
+ * @returns Upload retry state and control functions
+ * @throws Error if used outside of PowerSyncProvider
+ *
+ * @example
+ * ```typescript
+ * function UploadRetryBanner() {
+ *   const {
+ *     isWaiting,
+ *     nextRetryAt,
+ *     maxRetriesReached,
+ *     retryCount,
+ *     manualRetry,
+ *     discardAndReconnect,
+ *   } = useUploadRetry();
+ *
+ *   if (maxRetriesReached) {
+ *     return (
+ *       <View>
+ *         <Text>Upload failed after {retryCount} attempts</Text>
+ *         <Button onPress={manualRetry}>Try Again</Button>
+ *         <Button onPress={discardAndReconnect}>Discard Changes</Button>
+ *       </View>
+ *     );
+ *   }
+ *
+ *   if (isWaiting && nextRetryAt) {
+ *     return (
+ *       <View>
+ *         <Text>Retrying in {Math.ceil((nextRetryAt.getTime() - Date.now()) / 1000)}s</Text>
+ *       </View>
+ *     );
+ *   }
+ *
+ *   return null;
+ * }
+ * ```
+ */
+declare function useUploadRetry(): {
+    isWaiting: boolean;
+    nextRetryAt: Date | null;
+    maxRetriesReached: boolean;
+    retryCount: number;
+    manualRetry: () => Promise<void>;
+    discardEntryAndReconnect: (entryId: number) => Promise<void>;
+};
 /**
  * Hook to access connection health status.
  *
@@ -1469,8 +1594,8 @@ interface UploadStatusResult {
     failedTransactions: FailedTransaction[];
     /** Trigger sync retry (reconnect) */
     retryAll: () => Promise<void>;
-    /** Dismiss all failures */
-    dismissAll: () => void;
+    /** Dismiss a specific failure by its ID */
+    dismissFailure: (failureId: string) => void;
 }
 /**
  * Hook to get overall upload status across all entities.
@@ -1559,5 +1684,75 @@ declare const useFailedTransactions: typeof useFailedTransactionsContext;
  * Alias for useCompletedTransactionsContext.
  */
 declare const useCompletedTransactions: typeof useCompletedTransactionsContext;
+/**
+ * Return type for useUploadBlockedReason hook.
+ */
+interface UploadBlockedReasonResult {
+    /** Whether uploads are currently blocked */
+    isBlocked: boolean;
+    /** The reason uploads are blocked */
+    reason: UploadBlockReason;
+    /** Human-readable description of why uploads are blocked */
+    description: string | null;
+    /** Whether an upload is actively in progress */
+    isUploading: boolean;
+}
+/**
+ * Hook to get why uploads are blocked.
+ * Derives block reason from existing sync mode, network, and connection state.
+ *
+ * @returns Upload blocked status with reason and description
+ *
+ * @example
+ * ```typescript
+ * function UploadBlockedBanner() {
+ *   const { isBlocked, reason, description } = useUploadBlockedReason();
+ *
+ *   if (!isBlocked) return null;
+ *
+ *   return <Banner>{description}</Banner>;
+ * }
+ * ```
+ */
+declare function useUploadBlockedReason(): UploadBlockedReasonResult;
+/**
+ * Return type for useRetryCountdown hook.
+ */
+interface RetryCountdownResult {
+    /** The soonest next retry time from all failed transactions */
+    nextRetryAt: Date | null;
+    /** Milliseconds until the next retry (0 if already past) */
+    timeUntilRetryMs: number;
+    /** Formatted countdown string (e.g., "5s", "1m 30s", "2m") or null if no retry scheduled */
+    formattedCountdown: string | null;
+}
+/**
+ * Hook for retry countdown display.
+ *
+ * @deprecated The nextRetryAt and backoffMs fields have been removed from FailedTransaction.
+ * PowerSync SDK now controls retry timing internally. This hook is retained for backward
+ * compatibility but will always return null values.
+ *
+ * @returns Retry countdown information (always returns null values)
+ */
+declare function useRetryCountdown(): RetryCountdownResult;
+
+/**
+ * Provider Constants for @pol-studios/powersync
+ *
+ * Exports constants used in the provider that may need to be accessed by UI components.
+ */
+/**
+ * Maximum number of upload retry attempts before stopping automatic retries.
+ * After this many attempts, the user must manually retry or discard the failed entries.
+ *
+ * Backoff delays: 4s, 8s, 16s, 32s, 64s, 128s, 256s (total: ~8.5 minutes)
+ */
+declare const UPLOAD_MAX_RETRIES = 7;
+/**
+ * Backoff delays in seconds for each retry attempt.
+ * Uses exponential backoff: 4s, 8s, 16s, 32s, 64s, 128s, 256s
+ */
+declare const UPLOAD_BACKOFF_DELAYS: readonly [4, 8, 16, 32, 64, 128, 256];
 
-export { AttachmentQueueContext, type BackgroundSyncCallbacks, type BackgroundSyncConfig, type BackgroundSyncStatus, CompletedTransactionsContext, type CompletedTransactionsContextValue, ConnectionHealthContext, type ConnectionHealthContextValue, ConnectionStatusContext, type ConnectionStatusContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, type DataLayerConfig, type DataLayerIntegration, type EntitySyncStatusResult, FailedTransactionsContext, type FailedTransactionsContextValue, type OfflineDataAttachmentConfig, OfflineDataProvider, type OfflineDataProviderConfig, type OfflineDataProviderProps, PendingMutationsContext, type PendingMutationsContextValue, type PowerSyncConfig, PowerSyncContext, type PowerSyncContextValue, PowerSyncProvider, type PowerSyncProviderProps, type PowerSyncSyncStatusSnapshot, ProviderBridge, type ProviderBridgeProps, SyncActivityContext, type SyncActivityContextValue, type SyncActivityResult, type SyncConfig, SyncMetricsContext, type SyncMetricsContextValue, SyncModeContext, type SyncModeContextValue, SyncStatusContext, type SyncStatusContextValue, type UploadStatusResult, useAttachmentQueue, useAttachmentQueueReady, useCompletedTransactions, useCompletedTransactionsContext, useConnectionHealth, useConnectionStatus, useDatabase, useDownloadProgress, useEntitySyncStatus, useFailedTransactions, useFailedTransactionsContext, useIsSyncing, useOnlineStatus, usePendingMutations, usePendingMutationsContext, usePlatform, usePowerSync, useSyncActivity, useSyncActivityContext, useSyncControl, useSyncMetrics, useSyncMode, useSyncModeContext, useSyncStatus, useUploadStatus };
+export { AttachmentQueueContext, type BackgroundSyncCallbacks, type BackgroundSyncConfig, type BackgroundSyncStatus, CompletedTransactionsContext, type CompletedTransactionsContextValue, ConnectionHealthContext, type ConnectionHealthContextValue, ConnectionStatusContext, type ConnectionStatusContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, type DataLayerConfig, type DataLayerIntegration, type EntitySyncStatusResult, FailedTransactionsContext, type FailedTransactionsContextValue, type OfflineDataAttachmentConfig, type OfflineDataProviderConfig, type OfflineDataProviderProps, PendingMutationsContext, type PendingMutationsContextValue, type PowerSyncConfig, PowerSyncContext, type PowerSyncContextValue, PowerSyncProvider, type PowerSyncProviderProps, type PowerSyncSyncStatusSnapshot, ProviderBridge, type ProviderBridgeProps, type ResetSyncOptions, type RetryCountdownResult, SyncActivityContext, type SyncActivityContextValue, type SyncActivityResult, type SyncConfig, SyncMetricsContext, type SyncMetricsContextValue, SyncModeContext, type SyncModeContextValue, SyncStatusContext, type SyncStatusContextValue, UPLOAD_BACKOFF_DELAYS, UPLOAD_MAX_RETRIES, type UploadBlockedReasonResult, type UploadStatusResult, useAttachmentQueue, useAttachmentQueueReady, useCompletedTransactions, useCompletedTransactionsContext, useConnectionHealth, useConnectionStatus, useDatabase, useDownloadProgress, useEntitySyncStatus, useFailedTransactions, useFailedTransactionsContext, useIsSyncing, useOnlineStatus, usePendingMutations, usePendingMutationsContext, usePlatform, usePowerSync, useRetryCountdown, useSyncActivity, useSyncActivityContext, useSyncControl, useSyncMetrics, useSyncMode, useSyncModeContext, useSyncStatus, useUploadBlockedReason, useUploadRetry, useUploadStatus };

package/dist/provider/index.js

@@ -1,18 +1,17 @@
 import {
-  OfflineDataProvider,
   PowerSyncProvider,
-  ProviderBridge
-} from "../chunk-VB737IVN.js";
-import "../chunk-YHTZ7VMV.js";
-import "../chunk-P6WOZO7H.js";
-import "../chunk-CACKC6XG.js";
-import "../chunk-55DKCJV4.js";
+  ProviderBridge,
+  UPLOAD_BACKOFF_DELAYS,
+  UPLOAD_MAX_RETRIES
+} from "../chunk-P4D6BQ4X.js";
+import "../chunk-PGEDE6IM.js";
 import {
   DEFAULT_CONNECTION_HEALTH,
   DEFAULT_SYNC_CONFIG,
   DEFAULT_SYNC_METRICS,
   DEFAULT_SYNC_STATUS
-} from "../chunk-24RDMMCL.js";
+} from "../chunk-2RDWLXJW.js";
+import "../chunk-OGUFUZSY.js";
 import {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -42,6 +41,7 @@ import {
   usePendingMutationsContext,
   usePlatform,
   usePowerSync,
+  useRetryCountdown,
   useSyncActivity,
   useSyncActivityContext,
   useSyncControl,
@@ -49,16 +49,17 @@ import {
   useSyncMode,
   useSyncModeContext,
   useSyncStatus,
+  useUploadBlockedReason,
+  useUploadRetry,
   useUploadStatus
-} from "../chunk-YSTEESEG.js";
-import "../chunk-CAB26E6F.js";
-import "../chunk-XAEII4ZX.js";
-import "../chunk-Z6VOBGTU.js";
-import "../chunk-CGL33PL4.js";
-import "../chunk-WN5ZJ3E2.js";
-import "../chunk-BGBQYQV3.js";
+} from "../chunk-74TBHWJ4.js";
+import "../chunk-NUGQOTEM.js";
+import "../chunk-UOMHWUHV.js";
 import "../chunk-FV2HXEIY.js";
+import "../chunk-CGL33PL4.js";
+import "../chunk-65A3SYJZ.js";
 import "../chunk-I2AYMY5O.js";
+import "../chunk-5WRI5ZAA.js";
 export {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -69,7 +70,6 @@ export {
   DEFAULT_SYNC_METRICS,
   DEFAULT_SYNC_STATUS,
   FailedTransactionsContext,
-  OfflineDataProvider,
   PendingMutationsContext,
   PowerSyncContext,
   PowerSyncProvider,
@@ -78,6 +78,8 @@ export {
   SyncMetricsContext,
   SyncModeContext,
   SyncStatusContext,
+  UPLOAD_BACKOFF_DELAYS,
+  UPLOAD_MAX_RETRIES,
   useAttachmentQueue,
   useAttachmentQueueReady,
   useCompletedTransactions,
@@ -95,6 +97,7 @@ export {
   usePendingMutationsContext,
   usePlatform,
   usePowerSync,
+  useRetryCountdown,
   useSyncActivity,
   useSyncActivityContext,
   useSyncControl,
@@ -102,6 +105,8 @@ export {
   useSyncMode,
   useSyncModeContext,
   useSyncStatus,
+  useUploadBlockedReason,
+  useUploadRetry,
   useUploadStatus
 };
 //# sourceMappingURL=index.js.map