@pol-studios/powersync 1.0.0

package/dist/core/index.d.ts

@@ -0,0 +1,197 @@
+import { g as SyncErrorType, i as ClassifiedError, f as SyncError, C as CrudEntry } from '../types-afHtE1U_.js';
+export { A as AbstractPowerSyncDatabase, k as CacheStats, j as CompactResult, h as CompletedTransaction, b as ConnectionHealth, o as CountRow, l as CrudTransaction, n as DbStatRow, D as DownloadProgress, E as EntitySyncState, F as FailedTransaction, r as FreelistCountRow, s as IntegrityCheckRow, I as IntegrityResult, q as PageCountRow, p as PageSizeRow, P as PowerSyncBackendConnector, m as SqliteTableRow, c as StorageInfo, d as StorageQuota, e as SyncMetrics, S as SyncMode, a as SyncStatus, T as TableCacheStats } from '../types-afHtE1U_.js';
+
+/**
+ * Constants for @pol-studios/powersync
+ *
+ * This module contains all configurable constants with sensible defaults.
+ * These can be overridden via configuration.
+ */
+/** Storage key prefix for all PowerSync-related keys */
+declare const STORAGE_KEY_PREFIX = "@pol-studios/powersync";
+/** Storage key for PowerSync enabled state */
+declare const STORAGE_KEY_ENABLED = "@pol-studios/powersync-enabled";
+/** Storage key for PowerSync paused state */
+declare const STORAGE_KEY_PAUSED = "@pol-studios/powersync-paused";
+/** Storage key for persisted sync metrics */
+declare const STORAGE_KEY_METRICS = "@pol-studios/powersync-metrics";
+/** Storage key for attachment queue settings */
+declare const STORAGE_KEY_ATTACHMENT_SETTINGS = "@pol-studios/powersync-attachment-settings";
+/** Storage key for sync mode */
+declare const STORAGE_KEY_SYNC_MODE = "@pol-studios/powersync-sync-mode";
+/** Default sync mode */
+declare const DEFAULT_SYNC_MODE: "push-pull";
+/** Interval between health checks in milliseconds */
+declare const HEALTH_CHECK_INTERVAL_MS = 30000;
+/** Timeout for individual health check queries */
+declare const HEALTH_CHECK_TIMEOUT_MS = 5000;
+/** Latency threshold above which connection is considered degraded */
+declare const LATENCY_DEGRADED_THRESHOLD_MS = 1000;
+/** Number of consecutive failures before marking as disconnected */
+declare const MAX_CONSECUTIVE_FAILURES = 2;
+/** Warning threshold for device free space (default: 100MB) */
+declare const STORAGE_WARNING_THRESHOLD: number;
+/** Critical threshold for device free space (default: 50MB) */
+declare const STORAGE_CRITICAL_THRESHOLD: number;
+/** Default maximum cache size for attachments */
+declare const DEFAULT_ATTACHMENT_CACHE_SIZE: number;
+/** Default number of concurrent attachment downloads */
+declare const DEFAULT_ATTACHMENT_CONCURRENCY = 50;
+/** Delay between retry passes for attachment downloads */
+declare const ATTACHMENT_RETRY_DELAY_MS = 5000;
+/** Timeout for individual attachment downloads */
+declare const ATTACHMENT_DOWNLOAD_TIMEOUT_MS = 60000;
+/** Default image compression quality (0.0 to 1.0) */
+declare const DEFAULT_COMPRESSION_QUALITY = 0.7;
+/** Maximum image width before resizing */
+declare const COMPRESSION_MAX_WIDTH = 2048;
+/** Skip compression for files smaller than this */
+declare const COMPRESSION_SKIP_SIZE_BYTES = 100000;
+/** Skip compression if already smaller than this */
+declare const COMPRESSION_TARGET_SIZE_BYTES = 300000;
+/** Stop downloads at this percentage of cache limit to leave headroom */
+declare const DOWNLOAD_STOP_THRESHOLD = 0.95;
+/** Trigger eviction at this percentage of cache limit */
+declare const EVICTION_TRIGGER_THRESHOLD = 1;
+/** Default sync interval for periodic sync mode */
+declare const DEFAULT_SYNC_INTERVAL_MS: number;
+/** Debounce time for status notifications */
+declare const STATUS_NOTIFY_THROTTLE_MS = 500;
+/** Cache TTL for stats queries */
+declare const STATS_CACHE_TTL_MS = 500;
+/** Default maximum retry attempts */
+declare const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
+/** Default base delay for retry backoff */
+declare const DEFAULT_RETRY_BASE_DELAY_MS = 1000;
+/** Default maximum delay between retries */
+declare const DEFAULT_RETRY_MAX_DELAY_MS = 30000;
+/** Default backoff multiplier */
+declare const DEFAULT_RETRY_BACKOFF_MULTIPLIER = 2;
+
+/**
+ * Custom Error Classes for @pol-studios/powersync
+ *
+ * This module provides specialized error classes for different failure scenarios.
+ */
+
+/**
+ * Base error class for PowerSync-related errors
+ */
+declare class PowerSyncError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when PowerSync initialization fails
+ */
+declare class InitializationError extends PowerSyncError {
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Error thrown when a sync operation fails
+ */
+declare class SyncOperationError extends PowerSyncError {
+    readonly errorType: SyncErrorType;
+    readonly cause?: Error;
+    constructor(message: string, errorType: SyncErrorType, cause?: Error);
+    /**
+     * Whether this error can be automatically retried
+     */
+    get isRetryable(): boolean;
+    /**
+     * Get a user-friendly error message
+     */
+    get userFriendlyMessage(): string;
+}
+/**
+ * Error thrown when a connector operation fails
+ */
+declare class ConnectorError extends PowerSyncError {
+    readonly operation: 'fetchCredentials' | 'uploadData';
+    readonly cause?: Error;
+    constructor(message: string, operation: 'fetchCredentials' | 'uploadData', cause?: Error);
+}
+/**
+ * Error thrown when an attachment operation fails
+ */
+declare class AttachmentError extends PowerSyncError {
+    readonly attachmentId: string;
+    readonly operation: 'download' | 'compress' | 'delete' | 'evict';
+    readonly cause?: Error;
+    constructor(message: string, attachmentId: string, operation: 'download' | 'compress' | 'delete' | 'evict', cause?: Error);
+}
+/**
+ * Error thrown when the platform adapter is missing required functionality
+ */
+declare class PlatformAdapterError extends PowerSyncError {
+    readonly missingFeature: string;
+    constructor(message: string, missingFeature: string);
+}
+/**
+ * Error thrown when configuration is invalid
+ */
+declare class ConfigurationError extends PowerSyncError {
+    readonly configKey?: string;
+    constructor(message: string, configKey?: string);
+}
+/**
+ * Classify an error into a SyncErrorType based on its message
+ *
+ * @param error - The error to classify
+ * @returns The classified error type
+ */
+declare function classifyError(error: Error): SyncErrorType;
+/**
+ * Create a SyncOperationError from a regular Error
+ *
+ * @param error - The original error
+ * @param message - Optional custom message
+ * @returns A classified SyncOperationError
+ */
+declare function toSyncOperationError(error: Error, message?: string): SyncOperationError;
+/**
+ * Classify a Supabase/PostgreSQL error into a structured result.
+ *
+ * This function analyzes errors from Supabase operations and determines:
+ * - The error type category
+ * - Whether the error is permanent (won't be fixed by retry)
+ * - Whether it's a conflict with existing data
+ * - A user-friendly message
+ *
+ * @param error - The error from a Supabase operation
+ * @returns Classified error information
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await supabase.from('users').insert({ email: 'duplicate@test.com' });
+ * } catch (error) {
+ *   const classified = classifySupabaseError(error);
+ *   if (classified.isPermanent) {
+ *     // Show error to user - retry won't help
+ *   }
+ * }
+ * ```
+ */
+declare function classifySupabaseError(error: unknown): ClassifiedError;
+/**
+ * Create a SyncError from a classified error result.
+ */
+declare function createSyncError(classified: ClassifiedError, originalMessage: string): SyncError;
+/**
+ * Generate a unique ID for a failed transaction.
+ * Uses a combination of timestamp and entry IDs to ensure uniqueness.
+ */
+declare function generateFailureId(entries: CrudEntry[]): string;
+/**
+ * Extract entity IDs from CRUD entries.
+ * Includes both the PowerSync entry ID and the record's 'id' from opData if different.
+ * This ensures we can match failures to entities regardless of which ID format is used.
+ */
+declare function extractEntityIds(entries: CrudEntry[]): string[];
+/**
+ * Extract unique table names from CRUD entries.
+ */
+declare function extractTableNames(entries: CrudEntry[]): string[];
+
+export { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_RETRY_DELAY_MS, AttachmentError, COMPRESSION_MAX_WIDTH, COMPRESSION_SKIP_SIZE_BYTES, COMPRESSION_TARGET_SIZE_BYTES, ClassifiedError, ConfigurationError, ConnectorError, CrudEntry, DEFAULT_ATTACHMENT_CACHE_SIZE, DEFAULT_ATTACHMENT_CONCURRENCY, DEFAULT_COMPRESSION_QUALITY, DEFAULT_MAX_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_SYNC_INTERVAL_MS, DEFAULT_SYNC_MODE, DOWNLOAD_STOP_THRESHOLD, EVICTION_TRIGGER_THRESHOLD, HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, InitializationError, LATENCY_DEGRADED_THRESHOLD_MS, MAX_CONSECUTIVE_FAILURES, PlatformAdapterError, PowerSyncError, STATS_CACHE_TTL_MS, STATUS_NOTIFY_THROTTLE_MS, STORAGE_CRITICAL_THRESHOLD, STORAGE_KEY_ATTACHMENT_SETTINGS, STORAGE_KEY_ENABLED, STORAGE_KEY_METRICS, STORAGE_KEY_PAUSED, STORAGE_KEY_PREFIX, STORAGE_KEY_SYNC_MODE, STORAGE_WARNING_THRESHOLD, SyncError, SyncErrorType, SyncOperationError, classifyError, classifySupabaseError, createSyncError, extractEntityIds, extractTableNames, generateFailureId, toSyncOperationError };

package/dist/core/index.js

@@ -0,0 +1,96 @@
+import "../chunk-W7HSR35B.js";
+import {
+  ATTACHMENT_DOWNLOAD_TIMEOUT_MS,
+  ATTACHMENT_RETRY_DELAY_MS,
+  COMPRESSION_MAX_WIDTH,
+  COMPRESSION_SKIP_SIZE_BYTES,
+  COMPRESSION_TARGET_SIZE_BYTES,
+  DEFAULT_ATTACHMENT_CACHE_SIZE,
+  DEFAULT_ATTACHMENT_CONCURRENCY,
+  DEFAULT_COMPRESSION_QUALITY,
+  DEFAULT_MAX_RETRY_ATTEMPTS,
+  DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+  DEFAULT_RETRY_BASE_DELAY_MS,
+  DEFAULT_RETRY_MAX_DELAY_MS,
+  DEFAULT_SYNC_INTERVAL_MS,
+  DEFAULT_SYNC_MODE,
+  DOWNLOAD_STOP_THRESHOLD,
+  EVICTION_TRIGGER_THRESHOLD,
+  HEALTH_CHECK_INTERVAL_MS,
+  HEALTH_CHECK_TIMEOUT_MS,
+  LATENCY_DEGRADED_THRESHOLD_MS,
+  MAX_CONSECUTIVE_FAILURES,
+  STATS_CACHE_TTL_MS,
+  STATUS_NOTIFY_THROTTLE_MS,
+  STORAGE_CRITICAL_THRESHOLD,
+  STORAGE_KEY_ATTACHMENT_SETTINGS,
+  STORAGE_KEY_ENABLED,
+  STORAGE_KEY_METRICS,
+  STORAGE_KEY_PAUSED,
+  STORAGE_KEY_PREFIX,
+  STORAGE_KEY_SYNC_MODE,
+  STORAGE_WARNING_THRESHOLD
+} from "../chunk-NPNBGCRC.js";
+import {
+  AttachmentError,
+  ConfigurationError,
+  ConnectorError,
+  InitializationError,
+  PlatformAdapterError,
+  PowerSyncError,
+  SyncOperationError,
+  classifyError,
+  classifySupabaseError,
+  createSyncError,
+  extractEntityIds,
+  extractTableNames,
+  generateFailureId,
+  toSyncOperationError
+} from "../chunk-CHRTN5PF.js";
+export {
+  ATTACHMENT_DOWNLOAD_TIMEOUT_MS,
+  ATTACHMENT_RETRY_DELAY_MS,
+  AttachmentError,
+  COMPRESSION_MAX_WIDTH,
+  COMPRESSION_SKIP_SIZE_BYTES,
+  COMPRESSION_TARGET_SIZE_BYTES,
+  ConfigurationError,
+  ConnectorError,
+  DEFAULT_ATTACHMENT_CACHE_SIZE,
+  DEFAULT_ATTACHMENT_CONCURRENCY,
+  DEFAULT_COMPRESSION_QUALITY,
+  DEFAULT_MAX_RETRY_ATTEMPTS,
+  DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+  DEFAULT_RETRY_BASE_DELAY_MS,
+  DEFAULT_RETRY_MAX_DELAY_MS,
+  DEFAULT_SYNC_INTERVAL_MS,
+  DEFAULT_SYNC_MODE,
+  DOWNLOAD_STOP_THRESHOLD,
+  EVICTION_TRIGGER_THRESHOLD,
+  HEALTH_CHECK_INTERVAL_MS,
+  HEALTH_CHECK_TIMEOUT_MS,
+  InitializationError,
+  LATENCY_DEGRADED_THRESHOLD_MS,
+  MAX_CONSECUTIVE_FAILURES,
+  PlatformAdapterError,
+  PowerSyncError,
+  STATS_CACHE_TTL_MS,
+  STATUS_NOTIFY_THROTTLE_MS,
+  STORAGE_CRITICAL_THRESHOLD,
+  STORAGE_KEY_ATTACHMENT_SETTINGS,
+  STORAGE_KEY_ENABLED,
+  STORAGE_KEY_METRICS,
+  STORAGE_KEY_PAUSED,
+  STORAGE_KEY_PREFIX,
+  STORAGE_KEY_SYNC_MODE,
+  STORAGE_WARNING_THRESHOLD,
+  SyncOperationError,
+  classifyError,
+  classifySupabaseError,
+  createSyncError,
+  extractEntityIds,
+  extractTableNames,
+  generateFailureId,
+  toSyncOperationError
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-nae7nzib.d.ts

@@ -0,0 +1,147 @@
+import { S as SupabaseConnector, a as SupabaseConnectorOptions } from './supabase-connector-D14-kl5v.js';
+import { A as AbstractPowerSyncDatabase } from './types-afHtE1U_.js';
+
+/**
+ * Conflict Types for @pol-studios/powersync
+ *
+ * Provides types for version-based conflict detection using AuditLog attribution.
+ */
+/**
+ * Represents a field-level conflict where both local and server changed the same field.
+ */
+interface FieldConflict {
+    /** The field name that has conflicting changes */
+    field: string;
+    /** The local (pending) value */
+    localValue: unknown;
+    /** The current server value */
+    serverValue: unknown;
+    /** User who made the server change (from AuditLog.changeBy) */
+    changedBy: string | null;
+    /** When the server change occurred (from AuditLog.changeAt) */
+    changedAt: Date;
+}
+/**
+ * Result of checking for conflicts between local changes and server state.
+ */
+interface ConflictCheckResult {
+    /** Whether any field conflicts were detected */
+    hasConflict: boolean;
+    /** List of field-level conflicts */
+    conflicts: FieldConflict[];
+    /** Fields that can safely sync (no server changes) */
+    nonConflictingChanges: string[];
+    /** The table name */
+    table: string;
+    /** The record ID */
+    recordId: string;
+}
+/**
+ * User's resolution choice for a conflict.
+ */
+type ConflictResolution = {
+    action: 'overwrite';
+} | {
+    action: 'keep-server';
+} | {
+    action: 'partial';
+    fields: string[];
+};
+/**
+ * Handler for conflict events in the connector.
+ */
+interface ConflictHandler {
+    /**
+     * Called when a conflict is detected during upload.
+     *
+     * @param result - The conflict check result
+     * @returns Resolution to apply, or null to queue for UI resolution
+     */
+    onConflict: (result: ConflictCheckResult) => Promise<ConflictResolution | null>;
+}
+/**
+ * Configuration for conflict detection behavior.
+ */
+interface ConflictDetectionConfig {
+    /** Tables to skip conflict detection (opt-out). Default: [] */
+    skipTables?: string[];
+    /** Fields to ignore in conflict detection. Default: ['updatedAt', 'createdAt'] */
+    ignoredFields?: string[];
+    /** Whether to enable conflict detection. Default: true */
+    enabled?: boolean;
+}
+
+/**
+ * Conflict-Aware Connector for @pol-studios/powersync
+ *
+ * Extends SupabaseConnector with version-based conflict detection.
+ * Tables with a _version column automatically get conflict checking.
+ */
+
+/**
+ * Options for ConflictAwareConnector.
+ */
+interface ConflictAwareConnectorOptions extends SupabaseConnectorOptions {
+    /** Handler for conflict resolution. If not provided, conflicts are logged. */
+    conflictHandler?: ConflictHandler;
+    /** Configuration for conflict detection behavior */
+    conflictDetection?: ConflictDetectionConfig;
+}
+/**
+ * A PowerSync connector with built-in conflict detection.
+ *
+ * This connector extends SupabaseConnector to add version-based conflict
+ * detection for tables with a `_version` column. When a conflict is detected,
+ * it calls the provided conflict handler to determine how to proceed.
+ *
+ * @example
+ * ```typescript
+ * const connector = new ConflictAwareConnector({
+ *   supabaseClient: supabase,
+ *   powerSyncUrl: POWERSYNC_URL,
+ *   conflictHandler: {
+ *     onConflict: async (result) => {
+ *       // Queue for UI resolution
+ *       conflictContext.addConflict(result);
+ *       return null; // Don't proceed with upload
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare class ConflictAwareConnector extends SupabaseConnector {
+    private readonly conflictHandler?;
+    private readonly conflictConfig?;
+    private readonly supabaseClient;
+    private readonly schemaRouterFn;
+    private versionColumnCache;
+    constructor(options: ConflictAwareConnectorOptions);
+    /**
+     * Override uploadData to check for conflicts before uploading.
+     *
+     * For each CRUD entry in the transaction:
+     * 1. Check if table has _version column (cached)
+     * 2. If yes, compare local vs server version
+     * 3. On version mismatch, query AuditLog for field conflicts
+     * 4. If conflicts found, call handler to determine resolution
+     * 5. Apply resolution or skip entry based on handler response
+     */
+    uploadData(database: AbstractPowerSyncDatabase): Promise<void>;
+    /**
+     * Check if a table has a _version column (cached).
+     */
+    private checkVersionColumn;
+    /**
+     * Filter opData to only include specified fields.
+     */
+    private filterFields;
+    /**
+     * Process a single CRUD entry - delegates to parent's private method.
+     *
+     * Note: This is a workaround since processCrudEntry is private in parent.
+     * We replicate the logic here for now.
+     */
+    private processEntry;
+}
+
+export { ConflictAwareConnector as C, type FieldConflict as F, type ConflictAwareConnectorOptions as a, type ConflictCheckResult as b, type ConflictResolution as c, type ConflictHandler as d, type ConflictDetectionConfig as e };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { A as AbstractPowerSyncDatabase } from './types-afHtE1U_.js';
+export { k as CacheStats, i as ClassifiedError, j as CompactResult, h as CompletedTransaction, b as ConnectionHealth, o as CountRow, C as CrudEntry, l as CrudTransaction, n as DbStatRow, D as DownloadProgress, E as EntitySyncState, F as FailedTransaction, r as FreelistCountRow, s as IntegrityCheckRow, I as IntegrityResult, q as PageCountRow, p as PageSizeRow, P as PowerSyncBackendConnector, m as SqliteTableRow, c as StorageInfo, d as StorageQuota, f as SyncError, g as SyncErrorType, e as SyncMetrics, S as SyncMode, a as SyncStatus, T as TableCacheStats } from './types-afHtE1U_.js';
+export { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_RETRY_DELAY_MS, AttachmentError, COMPRESSION_MAX_WIDTH, COMPRESSION_SKIP_SIZE_BYTES, COMPRESSION_TARGET_SIZE_BYTES, ConfigurationError, ConnectorError, DEFAULT_ATTACHMENT_CACHE_SIZE, DEFAULT_ATTACHMENT_CONCURRENCY, DEFAULT_COMPRESSION_QUALITY, DEFAULT_MAX_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_SYNC_INTERVAL_MS, DEFAULT_SYNC_MODE, DOWNLOAD_STOP_THRESHOLD, EVICTION_TRIGGER_THRESHOLD, HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, InitializationError, LATENCY_DEGRADED_THRESHOLD_MS, MAX_CONSECUTIVE_FAILURES, PlatformAdapterError, PowerSyncError, STATS_CACHE_TTL_MS, STATUS_NOTIFY_THROTTLE_MS, STORAGE_CRITICAL_THRESHOLD, STORAGE_KEY_ATTACHMENT_SETTINGS, STORAGE_KEY_ENABLED, STORAGE_KEY_METRICS, STORAGE_KEY_PAUSED, STORAGE_KEY_PREFIX, STORAGE_KEY_SYNC_MODE, STORAGE_WARNING_THRESHOLD, SyncOperationError, classifyError, classifySupabaseError, createSyncError, extractEntityIds, extractTableNames, generateFailureId, toSyncOperationError } from './core/index.js';
+export { C as ConnectorConfig, c as CrudHandler, P as PowerSyncCredentials, b as SchemaRouter, S as SupabaseConnector, a as SupabaseConnectorOptions, d as defaultSchemaRouter } from './supabase-connector-D14-kl5v.js';
+import { e as ConflictDetectionConfig, b as ConflictCheckResult } from './index-nae7nzib.js';
+export { C as ConflictAwareConnector, a as ConflictAwareConnectorOptions, d as ConflictHandler, c as ConflictResolution, F as FieldConflict } from './index-nae7nzib.js';
+export { AttachmentQueue, AttachmentQueueConfig, AttachmentRecord, AttachmentSourceConfig, AttachmentState, AttachmentStatsRow, AttachmentStorageAdapter, AttachmentSyncStats, AttachmentSyncStatus, CacheConfig, CacheFileRow, CachedSizeRow, CompressionConfig, DEFAULT_CACHE_CONFIG, DEFAULT_COMPRESSION_CONFIG, DEFAULT_DOWNLOAD_CONFIG, DownloadConfig, DownloadPhase, DownloadStatus, EvictRow, IdRow } from './attachments/index.js';
+export { e as HealthCheckResult, H as HealthMonitorOptions, M as MetricsCollectorOptions, P as PowerSyncRawStatus, c as SyncControlActions, f as SyncEvent, g as SyncEventListener, d as SyncOperationData, S as SyncScope, a as SyncStatusState, b as SyncStatusTrackerOptions, U as Unsubscribe } from './types-Cd7RhNqf.js';
+export { HealthMonitor, MetricsCollector, SyncStatusTracker } from './sync/index.js';
+import { SupabaseClient } from '@supabase/supabase-js';
+export { AttachmentQueueContext, ConnectionHealthContext, ConnectionHealthContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, EntitySyncStatusResult, PowerSyncConfig, PowerSyncContext, PowerSyncContextValue, PowerSyncProvider, PowerSyncProviderProps, SyncActivityResult, SyncConfig, SyncMetricsContext, SyncMetricsContextValue, SyncStatusContext, SyncStatusContextValue, UploadStatusResult, useAttachmentQueue, useConnectionHealth, useDatabase, useDownloadProgress, useEntitySyncStatus, useIsSyncing, useOnlineStatus, usePendingMutations, usePlatform, usePowerSync, useSyncActivity, useSyncControl, useSyncMetrics, useSyncMode, useSyncStatus, useUploadStatus } from './provider/index.js';
+export { AsyncStorageAdapter, CompressedImage, CompressionOptions, ConnectionType, DatabaseOptions, FileInfo, FileSystemAdapter, ImageProcessorAdapter, LoggerAdapter, NetworkAdapter, PlatformAdapter, PlatformType, detectPlatform } from './platform/index.js';
+import '@tanstack/react-query';
+import 'react';
+
+/**
+ * Conflict Detection for @pol-studios/powersync
+ *
+ * Provides version-based conflict detection using AuditLog attribution.
+ * Only queries AuditLog when version mismatch is detected.
+ */
+
+/**
+ * Detect conflicts between local pending changes and server state.
+ *
+ * Uses a two-step approach:
+ * 1. Version match (local._version == server._version) → Sync immediately
+ * 2. Version mismatch → Query AuditLog for field changes and attribution
+ *
+ * @param table - The table name
+ * @param recordId - The record ID
+ * @param localVersion - Version number from local SQLite
+ * @param serverVersion - Version number from server (fetched separately)
+ * @param pendingChanges - Fields with local changes to sync
+ * @param supabase - Supabase client for AuditLog queries
+ * @param config - Optional detection configuration
+ * @returns Conflict check result with field-level details
+ */
+declare function detectConflicts(table: string, recordId: string, localVersion: number, serverVersion: number, pendingChanges: Record<string, unknown>, supabase: SupabaseClient, config?: ConflictDetectionConfig): Promise<ConflictCheckResult>;
+/**
+ * Check if a table has a _version column for conflict detection.
+ *
+ * @param table - The table name
+ * @param db - PowerSync database instance
+ * @returns True if the table has version tracking
+ */
+declare function hasVersionColumn(table: string, db: AbstractPowerSyncDatabase): Promise<boolean>;
+/**
+ * Fetch the current server version for a record.
+ *
+ * @param table - The table name
+ * @param recordId - The record ID
+ * @param schema - The Supabase schema (default: 'public')
+ * @param supabase - Supabase client
+ * @returns The server version number, or null if record not found
+ */
+declare function fetchServerVersion(table: string, recordId: string, schema: string, supabase: SupabaseClient): Promise<number | null>;
+/**
+ * Get the local version for a record from PowerSync SQLite.
+ *
+ * @param table - The table name
+ * @param recordId - The record ID
+ * @param db - PowerSync database instance
+ * @returns The local version number, or null if not found
+ */
+declare function getLocalVersion(table: string, recordId: string, db: AbstractPowerSyncDatabase): Promise<number | null>;
+
+export { AbstractPowerSyncDatabase, ConflictCheckResult, ConflictDetectionConfig, detectConflicts, fetchServerVersion, getLocalVersion, hasVersionColumn };