@pol-studios/db 1.0.10 → 1.0.12

package/dist/index.native.d.ts

@@ -1,35 +1,38 @@
-export { B as BooleanOperator, l as ClarificationQuestion, k as ClarificationSuggestion, C as CompositeTypes, j as ComputedSortConfig, c as Constants, D as Database, d as DbChangeLog, E as Enums, f as Filter, e as FilterConditionType, m as FilterContextType, g as FilterGroup, h as FilterInput, F as FilterOperator, i as FilterState, J as Json, O as OrderColumn, P as Pagination, Q as QueryState, S as Sort, T as Tables, a as TablesInsert, b as TablesUpdate, V as ValueOrArrayForPropertyType, n as normalizeFilter, u as useDbAdvanceFilterQuery, u as useDbAdvanceQuery } from './index-BFu5_dS8.js';
+export { C as CompositeTypes, c as Constants, D as Database, E as Enums, J as Json, T as Tables, a as TablesInsert, b as TablesUpdate } from './database.types-ChFCG-4M.js';
 export { a as FilterConfig, F as FilterConfigOption, G as Group, P as PropertyType, S as SortConfig, T as TableInfo, V as ValueForPropertyType, W as WhereFilter } from './FilterConfig-Bt2Ek74z.js';
-export { C as AIOptions, D as AIResponse, V as AlertProps, N as BUCKETS, O as BucketName, K as CustomPageQueryResult, Q as DEFAULT_QUERY_TIMEOUT, ac as FeedbackListItem, ad as FeedbackListParams, W as LiveChangeContext, X as LiveChangeContextProvider, M as MutationOption, F as ServerAvailabilityState, L as StorageObjectMetadata, af as SubmitFeedbackParams, S as SupabaseAdapter, T as TIMEOUT_ERROR_MESSAGE, I as UpdateOptions, U as UseDbPartialAdvanceQueryResult, q as UseDbPartialQueryResult, t as UseDbRealtimeQueryResult, x as UseMutationSuccessOptions, v as convertFilterToRealtimeQuery, P as createInCondition, A as createSupabaseAdapter, J as executeAdvanceQuery, B as getErrorBody, l as getSupabaseUrl, R as isTimeoutError, n as newTimeActivity, s as setSupabaseUrl, E as useAI, ag as useApplyFeedback, h as useAutosaveState, a7 as useChangelogById, a8 as useChangelogBySlug, a9 as useChangelogEntries, aa as useChangelogMedia, a5 as useChangelogs, c as useDbDelete, a as useDbInsert, m as useDbMultiDelete, o as useDbMultiUpsert, p as useDbPartialAdvanceQuery, r as useDbPartialQuery, u as useDbRealtime, e as useDbRealtimeQuery, b as useDbUpdate, d as useDbUpsert, w as useDbUpsertResponse, c as useDelete, Z as useDeleteChangelog, a0 as useDeleteChangelogEntry, a3 as useDeleteChangelogMedia, ab as useFeedbackList, a as useInsert, g as useLatestOperationLog, f as useLiveChangeTracking, a1 as useMultiDeleteChangelogEntries, $ as useMultiUpsertChangelogEntries, y as useMutationSuccess, z as useMutationSuccessRN, a6 as usePublishedChangelogs, u as useRealtime, e as useRealtimeQuery, ah as useResolveFeedback, H as useSearchQuery, G as useServerAvailability, k as useStoragePath, j as useStorageUrl, ae as useSubmitFeedback, i as useToastError, b as useUpdate, a4 as useUploadChangelogMedia, d as useUpsert, Y as useUpsertChangelog, _ as useUpsertChangelogEntry, a2 as useUpsertChangelogMedia } from './useResolveFeedback-CpZPP8Pw.js';
+export { r as BackendSelectionResult, B as BooleanOperator, l as ClarificationQuestion, k as ClarificationSuggestion, C as CombinedProviderStatus, j as ComputedSortConfig, n as DataLayerWithPowerSyncProps, D as DbChangeLog, a as EnhancedSyncControl, E as EnhancedSyncStatus, e as Filter, d as FilterConditionType, m as FilterContextType, f as FilterGroup, g as FilterInput, F as FilterOperator, h as FilterState, H as HasPowerSyncConfig, O as OrderColumn, i as Pagination, P as PowerSyncEnabledConfig, b as PowerSyncEnabledContextValue, q as PowerSyncTables, Q as QueryState, S as Sort, U as UseDataLayerWithPowerSync, p as UseSyncControlWithPowerSync, o as UseSyncStatusWithPowerSync, V as ValueOrArrayForPropertyType, c as createCombinedStatus, s as normalizeFilter, u as useDbAdvanceFilterQuery, u as useDbAdvanceQuery } from './index-CQLyNG6A.js';
+export { A as AIOptions, B as AIResponse, P as AlertProps, K as BUCKETS, L as BucketName, I as CustomPageQueryResult, N as DEFAULT_QUERY_TIMEOUT, a9 as FeedbackListItem, aa as FeedbackListParams, Q as LiveChangeContext, R as LiveChangeContextProvider, D as ServerAvailabilityState, J as StorageObjectMetadata, ac as SubmitFeedbackParams, S as SupabaseAdapter, T as TIMEOUT_ERROR_MESSAGE, G as UpdateOptions, U as UseDbPartialAdvanceQueryResult, p as UseDbPartialQueryResult, r as UseDbRealtimeQueryResult, v as UseMutationSuccessOptions, t as convertFilterToRealtimeQuery, M as createInCondition, y as createSupabaseAdapter, H as executeAdvanceQuery, z as getErrorBody, k as getSupabaseUrl, O as isTimeoutError, n as newTimeActivity, s as setSupabaseUrl, C as useAI, ad as useApplyFeedback, g as useAutosaveState, a4 as useChangelogById, a5 as useChangelogBySlug, a6 as useChangelogEntries, a7 as useChangelogMedia, a2 as useChangelogs, c as useDbDelete, a as useDbInsert, l as useDbMultiDelete, m as useDbMultiUpsert, o as useDbPartialAdvanceQuery, q as useDbPartialQuery, u as useDbRealtime, d as useDbRealtimeQuery, b as useDbUpdate, c as useDelete, W as useDeleteChangelog, Z as useDeleteChangelogEntry, a0 as useDeleteChangelogMedia, a8 as useFeedbackList, a as useInsert, f as useLatestOperationLog, e as useLiveChangeTracking, _ as useMultiDeleteChangelogEntries, Y as useMultiUpsertChangelogEntries, w as useMutationSuccess, x as useMutationSuccessRN, a3 as usePublishedChangelogs, u as useRealtime, d as useRealtimeQuery, ae as useResolveFeedback, F as useSearchQuery, E as useServerAvailability, j as useStoragePath, i as useStorageUrl, ab as useSubmitFeedback, h as useToastError, b as useUpdate, a1 as useUploadChangelogMedia, V as useUpsertChangelog, X as useUpsertChangelogEntry, $ as useUpsertChangelogMedia } from './useResolveFeedback-BWmatBlE.js';
 export { F as Fetch, i as GenericFunction, g as GenericNonUpdatableView, j as GenericSchema, G as GenericTable, f as GenericUpdatableView, h as GenericView, P as PostgrestError, d as PostgrestMaybeSingleResponse, e as PostgrestResponse, b as PostgrestResponseFailure, a as PostgrestResponseSuccess, c as PostgrestSingleResponse, k as Prettify } from './types-CYr9JiUE.js';
 export { U as UseDbQuerySingleReturn, u as useDbQuery } from './useDbQuery-C-TL8jY1.js';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient } from '@tanstack/react-query';
 import { FileOptions } from '@supabase/storage-js';
-export { u as useBatchDelete, a as useBatchUpsert } from './useBatchUpsert-CSQVX7w8.js';
+export { D as DatabaseTypes, P as PublicTableNames, R as ResolveRowType, S as SchemaNames, j as SchemaTableNames, T as TableIdentifier, p as UseAdvanceQueryOptions, q as UseAdvanceQueryResult, l as UseDbCountOptions, m as UseDbCountResult, U as UseDbInfiniteQueryOptions, k as UseDbInfiniteQueryResult, o as UseDbQueryOptions, n as UseDbQueryResult, i as useAdvanceQuery, a as useDataLayer, h as useDbCount, h as useDbCountV3, b as useDbDeleteV3, g as useDbInfiniteQuery, g as useDbInfiniteQueryV3, c as useDbInsertV3, e as useDbQueryById, d as useDbQueryV3, f as useDbUpdateV3, u as useDbUpsert, u as useDbUpsertV3, u as useUpsert } from './useDbCount-BG356T9i.js';
+export { useOnlineStatus, useSyncControl, useSyncStatus } from './hooks/index.js';
+export { u as useBatchDelete, a as useBatchUpsert } from './useBatchUpsert-9OYjibLh.js';
 import { DatabaseSchema, QueryOptions, DataLayerConfig } from './core/index.js';
 export { AdapterRegistry as AdapterRegistryInterface, AutoStrategy, BuiltQuery, CachedStrategy, ColumnInfo, ColumnType, ConnectionConfig, DataAdapter, DataLayerHooks, DeleteMutationResult, ExtractInsert, ExtractRow, ExtractUpdate, HybridStrategy, MutationHookResult, MutationResult, OrderBy, ParsedSelect, PowerSyncStrategy, QueryResult, QuerySingleResult, RelationshipInfo, RelationshipType, ResolvedRelationship, ScopeDefinition, SelectColumn, SelectRelation, SupabaseStrategy, SyncControl, SyncMode, SyncScope, SyncStatus, TableNames, TableSchema, TableStrategy, UseDbMutationHook, UseDbQueryByIdHook, UseDbQueryHook, WhereClause, WhereOperators } from './core/index.js';
 export { UsePartialAdvancedQueryResult, UsePartialQueryResult, UseQuerySingleReturn, extractColumnNames, extractRelationNames, getRelationSelect, hasRelation, parseSelect, stringifySelect, tokenizeTopLevel, useAdvancedFilterQuery, useAdvancedQuery, useInfiniteQuery, usePartialAdvancedQuery, usePartialQuery, useQuery } from './query/index.js';
 import { Q as QueryExecutor, P as PowerSyncDatabase$1 } from './executor-CB4KHyYG.js';
 export { e as RelationJoinData, R as RelationshipResolver, b as ResultJoiner, S as SQLBuilder, f as createQueryExecutor, c as createRelationshipResolver, d as createResultJoiner, a as createSQLBuilder } from './executor-CB4KHyYG.js';
-import { r as TableDataAdapter, C as CapableDataAdapter, v as AdapterCapabilities, A as AdapterQueryResult, L as DataLayerContextValue } from './useDbCount-RGCuHmHp.js';
-export { y as ADAPTER_STRATEGIES, E as AdapterAutoDetector, s as AdapterConfig, w as AdapterDependencies, t as AdapterFactory, z as AdapterRegistry, x as AdapterStrategyType, H as AutoDetectionResult, I as AutoDetectorOptions, J as BackendChangeListener, G as BackendStatus, K as DataLayerContext, M as DataLayerStatus, D as DatabaseTypes, P as PublicTableNames, R as ResolveRowType, S as SchemaNames, j as SchemaTableNames, T as TableIdentifier, p as UseAdvanceQueryOptions, q as UseAdvanceQueryResult, l as UseDbCountOptions, m as UseDbCountResult, U as UseDbInfiniteQueryOptions, k as UseDbInfiniteQueryResult, o as UseDbQueryOptions, n as UseDbQueryResult, F as createAdapterAutoDetector, B as createAdapterRegistry, i as useAdvanceQuery, u as useDataLayer, h as useDbCount, h as useDbCountV3, a as useDbDeleteV3, g as useDbInfiniteQuery, g as useDbInfiniteQueryV3, b as useDbInsertV3, d as useDbQueryById, c as useDbQueryV3, e as useDbUpdateV3, f as useDbUpsertV3 } from './useDbCount-RGCuHmHp.js';
+import { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult, n as DataLayerContextValue, S as SyncStatusInfo } from './DataLayerContext-CL6alnkb.js';
+export { f as ADAPTER_STRATEGIES, i as AdapterAutoDetector, a as AdapterConfig, d as AdapterDependencies, b as AdapterFactory, g as AdapterRegistry, e as AdapterStrategyType, k as AutoDetectionResult, l as AutoDetectorOptions, m as BackendChangeListener, B as BackendStatus, D as DataLayerContext, o as DataLayerStatus, j as createAdapterAutoDetector, h as createAdapterRegistry } from './DataLayerContext-CL6alnkb.js';
 import * as react from 'react';
-import { ReactNode, JSX } from 'react';
+import react__default, { ReactNode, JSX } from 'react';
 import { SupabaseClient } from '@supabase/supabase-js';
-export { useOnlineStatus, useSyncControl, useSyncStatus } from './hooks/index.js';
-export { S as SupabaseDatabaseTypes, a as SupabaseProvider, T as TypedSupabaseClient, U as UserSessionId, c as createNewSupabaseClient, u as default, o as onSupabaseInitialized, s as setDefaultOptions, t as typedSupabase, u as useSupabase } from './useSupabase-pPhUZHcl.js';
+export { C as ClientInstanceId, S as SupabaseDatabaseTypes, a as SupabaseProvider, T as TypedSupabaseClient, U as UserSessionId, c as createNewSupabaseClient, u as default, o as onSupabaseInitialized, s as setDefaultOptions, t as typedSupabase, u as useSupabase } from './useSupabase-DvWVuHHE.js';
+export { e as UserMetadataContextProvider, c as UserMetadataContextType, a as UserMetadataInsert, U as UserMetadataRow, b as UserMetadataUpdate, u as useLiveChangesIndicator, h as useSetUserMetadata, f as useUserMetadata, i as useUserMetadataState, g as useUserMetadataValue, d as userMetadataContext } from './UserMetadataContext-B8gVWGMl.js';
 import * as react_dropzone from 'react-dropzone';
 import { FileRejection, FileError } from 'react-dropzone';
 export { AnyPostgrestResponse, FilterDefinition, FilterDefinitions, FilterFn, NestedPath, OPERATOR_MAP, OperatorFn, OrderDefinition, Path, PostgrestFilter, PostgrestFilterOperator, PostgrestHasMorePaginationCacheData, PostgrestHasMorePaginationResponse, PostgrestPaginationCacheData, PostgrestPaginationResponse, PostgrestParser, PostgrestQueryParser, PostgrestQueryParserOptions, SUPPORTED_OPERATORS, ValueType, binarySearch, buildSortedComparator, denormalize, encodeObject, extractPathsFromFilters, filterFilterDefinitionsByPaths, findFilters, findIndexOrdered, findLastIndex, get, getTable, groupPathsRecursive, ifDateGetTime, isAndFilter, isAnyPostgrestResponse, isFilterDefinition, isISODateString, isNestedPath, isNotNull, isObject, isOrFilter, isPostgrestBuilder, isPostgrestHasMorePaginationCacheData, isPostgrestHasMorePaginationResponse, isPostgrestPaginationCacheData, isPostgrestPaginationResponse, parseOrderByKey, parseSelectParam, parseValue, removeAliasFromDeclaration, removeFirstPathElement, setFilterValue, sortSearchParams } from './parser/index.js';
 export { G as GetResult, S as SelectQueryError } from './select-query-parser-BwyHum1L.js';
 export { Accessory, Address, AdvanceQuery, AdvanceQueryNotificationSetting, AdvancedQueryView, BillableService, BillingDetails, CachedEmbedding, Changelog, ChangelogEntry, ChangelogMedia, ChargeTable, Circuit, Client, Comment, CommentReaction, CommentRead, CommentSection, CommentTag, CommonNote, CommonNoteCategory, CommonNoteSubCategory, ControlComponent, ControlComponentDatasheet, Controller, CoreSavedQuery, CoreSavedQueryAccess, Currency, CurrencyUsdConversion, DataExchangeImport, Datasheet, Dimension, DimmerModule, DimmerRack, Embedding, EquipmentConfigurationGroup, EquipmentFixture, EquipmentFixtureConfiguration, EquipmentFixtureConfigurationAccessoryEntry, EquipmentFixtureConfigurationControlComponentEntry, EquipmentFixtureCost, EquipmentFixtureDatasheet, EquipmentFixtureDimension, EquipmentFixtureDocument, EquipmentFixtureLampConfiguration, EquipmentFixtureListing, EquipmentFixtureMode, EquipmentFixtureModeChannel, EquipmentFixturePreset, EquipmentFixtureUnit, EquipmentFixtureUnitControl, EquipmentFixtureUnitLocation, EquipmentFixtureUnitLocationTag, EquipmentFixtureUnitLocationTagValue, EquipmentFixtureUnitPatternEntry, EquipmentFixtureWeight, EquipmentType, EquipmentUnitMediaContent, Expense, ExpenseLineItem, ExpenseReport, Fixture, FixtureCatalog, FixtureCatalogItem, FixtureCategory, FixtureTag, GlobalExpenseReport, HighlightServer, HighlightServerInstance, HighlightServerInstanceLog, HighlightServerInstanceOptions, HighlightServerInstanceStatus, HighlightServerRequest, Invoice, InvoiceSummaryTable, InvoiceTerm, InvoiceTermCondition, Lamp, LampCategory, LampCurrentListing, LampType, LicenseAssignment, Logo, Manufacturer, ManufacturerTag, ManufacturerToTag, OperationLog, OrderHinted, Organization, OrganizationUser, OrganizationUserAccess, ParameterMappingProfile, ParameterMappingProfileAssignment, Pattern, PaymentCustomer, PaymentInvoice, PaymentPaymentIntents, PaymentPlan, PaymentProduct, PaymentProductFeature, PaymentSubscription, PaymentSubscriptionPlan, PhaseActivityBucket, ProfileConfig as Profile, ProfileConfig, ProfileTimeBank, Project, ProjectDatabase, ProjectDatabaseEquipmentConfigurationGroup, ProjectDatabaseExcelParameterAssignment, ProjectDatabaseGroup, ProjectDatabaseParameterMappingProfile, ProjectDefaultRateByTitle, ProjectDocument, ProjectDocumentLineItem, PunchList, PunchListAccess, PunchListItem, PunchListItemAssignment, PunchListItemAttachedEntity, PunchListItemAttachment, PunchListItemCheckListItem, PunchListPage, PunchListPageAccess, PunchListUserOrderHint, QrCode, RetainageItem, RevitEquipmentUnitChange, RevitImport, RevitValueChangedEvent, Role, Service, ServiceCosts, ServiceStorageHourly, SmartCode, SmartCodeTag, Subtask, SystemBroadcastChannel, SystemBroadcastChannelThrottle, SystemConfiguration, SystemEmailNotification, SystemEvent, SystemEventListener, SystemEventWorker, SystemGlobalVariables, SystemHealthCheck, SystemInAppNotification, SystemLog, SystemMutedTopic, SystemNotification, SystemPushNotification, SystemSubscriber, SystemSupportAccess, SystemSupportTeam, SystemTask, SystemTaskAttempt, SystemTaskAttemptAccess, SystemTemp, SystemTicket, SystemTicketAttachment, SystemTicketComment, SystemTicketCommentAttachment, SystemUserPushTokens, Tag, Task, TaxCategory, Ticket, TicketAttachment, TicketComment, TicketCommentAttachment, TimeActivity, TimeBankTransaction, UserMetadata, UserTimesheet, WeeklyTimesheet, WorkEstimation, WorkEstimationLineItem, WorkingPhase, WorkingPhaseBillingItemDailySummary, WorkingPhaseBillingItemLatestSummary, WorkingPhaseCategory, WorkingPhaseDailySummary, WorkingPhaseRoleRate, WorkingPhaseSummary } from './gen/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import 'moment';
 import '@supabase-cache-helpers/postgrest-react-query';
 import '@pol-studios/utils';
 import '@supabase/functions-js';
 import '@supabase/postgrest-js';
-import 'react/jsx-runtime';
 import '@supabase/supabase-js/dist/module/lib/types.js';
 
 type RequestOptions = {
@@ -273,7 +276,32 @@ interface DataLayerProviderProps {
     config: DataLayerConfig;
     /** Children to render */
     children: ReactNode;
-    /** Optional PowerSync database instance */
+    /**
+     * Optional PowerSync database instance.
+     *
+     * This accepts any object that implements the PowerSyncDatabase interface,
+     * including the AbstractPowerSyncDatabase from @pol-studios/powersync.
+     *
+     * When using with @pol-studios/powersync, pass the `db` value from usePowerSync():
+     * @example
+     * ```tsx
+     * // With @pol-studios/powersync
+     * const { db, isReady } = usePowerSync();
+     *
+     * if (!isReady) return <Loading />;
+     *
+     * return (
+     *   <DataLayerProvider
+     *     config={config}
+     *     powerSyncInstance={db}
+     *     supabaseClient={supabase}
+     *     queryClient={queryClient}
+     *   >
+     *     {children}
+     *   </DataLayerProvider>
+     * );
+     * ```
+     */
     powerSyncInstance?: PowerSyncDatabase$1 | null;
     /** Supabase client (required) */
     supabaseClient: SupabaseClient;
@@ -283,6 +311,13 @@ interface DataLayerProviderProps {
     onInitialized?: (context: DataLayerContextValue) => void;
     /** Callback when error occurs */
     onError?: (error: Error) => void;
+    /**
+     * Current sync status from @pol-studios/powersync.
+     * Pass the status object from useSyncStatus() hook.
+     * When hasSynced is false and useOnlineUntilSynced is true (default),
+     * queries will use Supabase until initial sync completes.
+     */
+    powerSyncSyncStatus?: SyncStatusInfo;
 }
 /**
  * Provider component for the V3 data layer.
@@ -312,7 +347,7 @@ interface DataLayerProviderProps {
  * }
  * ```
  */
-declare function DataLayerProvider({ config, children, powerSyncInstance, supabaseClient, queryClient, onInitialized, onError, }: DataLayerProviderProps): JSX.Element;
+declare function DataLayerProvider({ config, children, powerSyncInstance, supabaseClient, queryClient, onInitialized, onError, powerSyncSyncStatus, }: DataLayerProviderProps): JSX.Element;
 
 interface FileWithPreview extends File {
     preview?: string;
@@ -392,42 +427,347 @@ declare const useSupabaseUpload: (options: UseSupabaseUploadOptions) => {
 };
 
 /**
- * Platform-aware network status utility
+ * Conflict Types for @pol-studios/db
+ *
+ * Canonical type definitions for conflict detection and resolution.
+ * These types are shared between @pol-studios/db and @pol-studios/powersync.
+ */
+/**
+ * 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[];
+};
+
+/**
+ * Interface for ConflictBus from @pol-studios/powersync.
+ * Defined here to avoid circular dependency between packages.
+ */
+interface ConflictBusInterface {
+    onConflict: (listener: (conflict: ConflictCheckResult) => void) => () => void;
+    onResolution: (listener: (table: string, recordId: string, resolution: ConflictResolution) => void) => () => void;
+    emitConflict: (conflict: ConflictCheckResult) => void;
+    emitResolution: (table: string, recordId: string, resolution: ConflictResolution) => void;
+}
+/**
+ * Context value provided to consumers.
+ */
+interface ConflictContextValue {
+    /** Current conflict state */
+    pendingConflicts: ConflictCheckResult[];
+    /** Add a conflict (called by connector) */
+    addConflict: (conflict: ConflictCheckResult) => void;
+    /** Resolve a single conflict by table and record ID */
+    resolveConflict: (table: string, recordId: string, resolution: ConflictResolution) => void;
+    /** Resolve all pending conflicts with the same resolution */
+    resolveAll: (resolution: ConflictResolution) => void;
+    /** Remove a conflict by table and record ID (after sync completes) */
+    removeConflict: (table: string, recordId: string) => void;
+    /** Get resolution for a specific table and record */
+    getResolution: (table: string, recordId: string) => ConflictResolution | undefined;
+    /** Clear all resolved conflicts from the resolutions map */
+    clearResolved: () => void;
+    /** Clear all conflicts (resolved and pending) */
+    clearAll: () => void;
+    /** Whether there are any pending conflicts */
+    hasConflicts: boolean;
+}
+declare const ConflictContext: react__default.Context<ConflictContextValue>;
+interface ConflictProviderProps {
+    children: react__default.ReactNode;
+    /**
+     * Optional: Event bus for receiving conflicts from the connector.
+     * When provided, the provider will:
+     * - Subscribe to conflict events and add them to state
+     * - Emit resolution events when conflicts are resolved
+     */
+    conflictBus?: ConflictBusInterface;
+}
+/**
+ * Provider component for conflict state management.
  *
- * Provides unified network connectivity detection for both web (browser)
- * and React Native environments.
+ * Wrap your app with this provider to enable conflict detection and resolution.
  *
- * - On React Native: Uses @react-native-community/netinfo
- * - On Web: Uses navigator.onLine and window online/offline events
+ * @example
+ * ```tsx
+ * <PowerSyncProvider connector={connector}>
+ *   <ConflictProvider>
+ *     <App />
+ *   </ConflictProvider>
+ * </PowerSyncProvider>
+ * ```
  */
+declare function ConflictProvider({ children, conflictBus }: ConflictProviderProps): react_jsx_runtime.JSX.Element;
+
 /**
- * Check if we're running in React Native environment
+ * Conflict State Hooks for @pol-studios/db
+ *
+ * Provides hooks for accessing and filtering conflict state.
  */
-declare function isReactNative(): boolean;
+
 /**
- * Get current online status
+ * Hook to access the full conflict state and actions.
+ *
+ * @throws Error if used outside of ConflictProvider
+ * @returns Full conflict context value
+ *
+ * @example
+ * ```tsx
+ * function ConflictManager() {
+ *   const { pendingConflicts, resolveAll, clearResolved } = useConflictState();
  *
- * @returns Promise resolving to true if online, false if offline
+ *   return (
+ *     <View>
+ *       <Text>{pendingConflicts.length} conflicts pending</Text>
+ *       <Button onPress={() => resolveAll({ action: 'keep-server' })}>
+ *         Accept All Server Changes
+ *       </Button>
+ *     </View>
+ *   );
+ * }
+ * ```
  */
-declare function getOnlineStatus(): Promise<boolean>;
+declare function useConflictState(): ConflictContextValue;
 /**
- * Get current online status synchronously (browser only, RN returns cached/default)
- * Use getOnlineStatus() for accurate cross-platform results
+ * Hook to get only pending conflicts (read-only).
+ *
+ * Use this when you only need to display conflicts without resolution actions.
+ *
+ * @returns Array of pending conflicts
  *
- * @returns true if online (or unknown), false if offline
+ * @example
+ * ```tsx
+ * function ConflictBadge() {
+ *   const conflicts = usePendingConflicts();
+ *   if (conflicts.length === 0) return null;
+ *   return <Badge count={conflicts.length} />;
+ * }
+ * ```
  */
-declare function getOnlineStatusSync(): boolean;
+declare function usePendingConflicts(): ConflictCheckResult[];
 /**
- * Subscribe to network status changes
+ * Hook to check if there are any pending conflicts.
  *
- * @param callback - Function called when online status changes
- * @returns Unsubscribe function
+ * Optimized for conditional rendering - only triggers re-render on boolean change.
+ *
+ * @returns True if there are pending conflicts
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const hasConflicts = useHasConflicts();
+ *   return (
+ *     <>
+ *       {hasConflicts && <ConflictBanner />}
+ *       <MainContent />
+ *     </>
+ *   );
+ * }
+ * ```
  */
-declare function subscribeToNetworkChanges(callback: (isOnline: boolean) => void): () => void;
+declare function useHasConflicts(): boolean;
 /**
- * Initialize network monitoring (call early in app lifecycle)
- * This pre-loads NetInfo on React Native for faster subsequent calls
+ * Hook to get a specific conflict by table and record ID.
+ *
+ * Returns null if no conflict exists for the record.
+ *
+ * @param table - The table name
+ * @param recordId - The record ID to look up
+ * @returns The conflict for this record, or null
+ *
+ * @example
+ * ```tsx
+ * function RecordEditor({ table, recordId }: { table: string; recordId: string }) {
+ *   const conflict = useConflictForRecord(table, recordId);
+ *
+ *   if (conflict) {
+ *     return <ConflictWarning conflict={conflict} />;
+ *   }
+ *
+ *   return <EditForm recordId={recordId} />;
+ * }
+ * ```
+ */
+declare function useConflictForRecord(table: string, recordId: string): ConflictCheckResult | null;
+/**
+ * Hook to get conflicts filtered by table name.
+ *
+ * Useful for showing conflicts scoped to a specific entity type.
+ *
+ * @param table - The table name to filter by
+ * @returns Conflicts for the specified table
+ *
+ * @example
+ * ```tsx
+ * function EquipmentConflicts() {
+ *   const conflicts = useConflictsForTable('EquipmentFixtureUnit');
+ *   return (
+ *     <FlatList
+ *       data={conflicts}
+ *       renderItem={({ item }) => <ConflictCard conflict={item} />}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useConflictsForTable(table: string): ConflictCheckResult[];
+/**
+ * Hook to get conflict count by table.
+ *
+ * Returns a map of table names to conflict counts for summary display.
+ *
+ * @returns Map of table name to conflict count
+ *
+ * @example
+ * ```tsx
+ * function ConflictSummary() {
+ *   const countByTable = useConflictCountByTable();
+ *   return (
+ *     <View>
+ *       {Array.from(countByTable.entries()).map(([table, count]) => (
+ *         <Text key={table}>{table}: {count} conflicts</Text>
+ *       ))}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useConflictCountByTable(): Map<string, number>;
+
+/**
+ * Conflict Resolution Hook for @pol-studios/db
+ *
+ * Provides methods for resolving individual conflicts.
+ */
+
+/**
+ * Return type for useConflictResolution hook.
  */
-declare function initializeNetworkMonitoring(): Promise<void>;
+interface UseConflictResolutionReturn {
+    /** The conflict being resolved */
+    conflict: ConflictCheckResult;
+    /** Resolve with a specific resolution */
+    resolve: (resolution: ConflictResolution) => void;
+    /** Accept server changes, discard local */
+    keepServer: () => void;
+    /** Overwrite server with local changes */
+    overwrite: () => void;
+    /** Only sync fields that don't conflict */
+    syncNonConflicting: () => void;
+    /** Sync specific fields only */
+    syncFields: (fields: string[]) => void;
+    /** Check if a specific field has a conflict */
+    hasFieldConflict: (field: string) => boolean;
+    /** Get conflict info for a specific field */
+    getFieldConflict: (field: string) => {
+        localValue: unknown;
+        serverValue: unknown;
+        changedBy: string | null;
+        changedAt: Date;
+    } | null;
+}
+/**
+ * Hook for resolving a specific conflict.
+ *
+ * Provides convenience methods for common resolution patterns.
+ *
+ * @param conflict - The conflict to resolve
+ * @returns Resolution methods and utilities
+ *
+ * @example
+ * ```tsx
+ * function ConflictCard({ conflict }: { conflict: ConflictCheckResult }) {
+ *   const {
+ *     keepServer,
+ *     overwrite,
+ *     syncNonConflicting,
+ *     hasFieldConflict,
+ *     getFieldConflict,
+ *   } = useConflictResolution(conflict);
+ *
+ *   return (
+ *     <Card>
+ *       <Text>Conflict on {conflict.table}</Text>
+ *       {conflict.conflicts.map(fc => (
+ *         <View key={fc.field}>
+ *           <Text>{fc.field}</Text>
+ *           <Text>Yours: {String(fc.localValue)}</Text>
+ *           <Text>Theirs: {String(fc.serverValue)} by {fc.changedBy}</Text>
+ *         </View>
+ *       ))}
+ *       <Button onPress={keepServer}>Keep Theirs</Button>
+ *       <Button onPress={overwrite}>Use Mine</Button>
+ *       <Button onPress={syncNonConflicting}>Sync Safe Fields Only</Button>
+ *     </Card>
+ *   );
+ * }
+ * ```
+ */
+declare function useConflictResolution(conflict: ConflictCheckResult): UseConflictResolutionReturn;
+/**
+ * Hook for bulk conflict resolution.
+ *
+ * Provides methods for resolving multiple conflicts at once.
+ *
+ * @returns Bulk resolution methods
+ *
+ * @example
+ * ```tsx
+ * function ConflictSummary() {
+ *   const conflicts = usePendingConflicts();
+ *   const { resolveAllKeepServer, resolveAllOverwrite } = useBulkConflictResolution();
+ *
+ *   return (
+ *     <View>
+ *       <Text>{conflicts.length} conflicts</Text>
+ *       <Button onPress={resolveAllKeepServer}>Accept All Server Changes</Button>
+ *       <Button onPress={resolveAllOverwrite}>Overwrite All with Mine</Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useBulkConflictResolution(): {
+    resolveAllKeepServer: () => void;
+    resolveAllOverwrite: () => void;
+    resolveAllSyncNonConflicting: () => void;
+    clearResolved: () => void;
+    conflictCount: number;
+};
 
-export { AdapterCapabilities, AdapterQueryResult, CapableDataAdapter, DataLayerConfig, DataLayerContextValue, DataLayerProvider, type DataLayerProviderProps, DatabaseSchema, PowerSyncAdapter, PowerSyncDatabase$1 as PowerSyncDatabase, QueryExecutor, QueryOptions, TableDataAdapter, type UseSupabaseUploadOptions, type UseSupabaseUploadReturn, createPowerSyncAdapter, getOnlineStatus, getOnlineStatusSync, initializeNetworkMonitoring, isReactNative, sanitizeStorageKey, subscribeToNetworkChanges, useDbAttachmentUpload as useDbUpload, useSupabaseUpload };
+export { AdapterCapabilities, AdapterQueryResult, CapableDataAdapter, type ConflictCheckResult, ConflictContext, type ConflictContextValue, ConflictProvider, type ConflictProviderProps, type ConflictResolution, DataLayerConfig, DataLayerContextValue, DataLayerProvider, type DataLayerProviderProps, DatabaseSchema, type FieldConflict, PowerSyncAdapter, PowerSyncDatabase$1 as PowerSyncDatabase, QueryExecutor, QueryOptions, SyncStatusInfo, TableDataAdapter, type UseConflictResolutionReturn, type UseSupabaseUploadOptions, type UseSupabaseUploadReturn, createPowerSyncAdapter, sanitizeStorageKey, useBulkConflictResolution, useConflictCountByTable, useConflictForRecord, useConflictResolution, useConflictState, useConflictsForTable, useDbAttachmentUpload as useDbUpload, useHasConflicts, usePendingConflicts, useSupabaseUpload };