@pol-studios/db 1.0.19 → 1.0.21

package/dist/index.native.d.ts

@@ -0,0 +1,793 @@
+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 { 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-BNKhgDdC.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-Ca2rh_Bs.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 { D as DatabaseTypes, P as PublicTableNames, R as ResolveRowType, S as SchemaNames, l as SchemaTableNames, T as TableIdentifier, r as UseAdvanceQueryOptions, s as UseAdvanceQueryResult, n as UseDbCountOptions, o as UseDbCountResult, U as UseDbInfiniteQueryOptions, m as UseDbInfiniteQueryResult, q as UseDbQueryOptions, p as UseDbQueryResult, k as useAdvanceQuery, a as useDataLayer, j as useDbCount, j as useDbCountV3, d as useDbDeleteV3, i as useDbInfiniteQuery, i as useDbInfiniteQueryV3, e as useDbInsertV3, g as useDbQueryById, f as useDbQueryV3, h as useDbUpdateV3, u as useDbUpsert, u as useDbUpsertV3, u as useUpsert } from './useDbCount-Id14x_1P.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 { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult, p as DataLayerContextValue, S as SyncStatusInfo } from './DataLayerContext-ZmLPYR_s.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, n as DataLayerCoreContext, q as DataLayerCoreContextValue, s as DataLayerStatus, o as DataLayerStatusContext, r as DataLayerStatusContextValue, j as createAdapterAutoDetector, h as createAdapterRegistry } from './DataLayerContext-ZmLPYR_s.js';
+import * as react from 'react';
+import react__default, { ReactNode, JSX } from 'react';
+import { SupabaseClient } from '@supabase/supabase-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 '@supabase/supabase-js/dist/module/lib/types.js';
+
+type RequestOptions = {
+    onUploadProgress?: (bytesUploaded: number, bytesTotal: number) => any;
+};
+declare function sanitizeStorageKey(path: string): string;
+declare function useDbAttachmentUpload(bucketId: string, options?: RequestOptions): _tanstack_react_query.UseMutationResult<{
+    bucketId: string;
+    path: string;
+    contentType: string;
+}, Error, {
+    directory?: string;
+    fileName?: string;
+    file: File | Blob | Pick<ReadableStreamDefaultReader, "read">;
+    onUploadProgress?: (bytesUploaded: number, bytesTotal: number) => any;
+} & FileOptions, unknown>;
+
+/**
+ * PowerSync Adapter
+ *
+ * Wraps the QueryExecutor to execute queries against PowerSync's local SQLite database.
+ * Implements the TableDataAdapter interface for use with the V3 data layer.
+ *
+ * This adapter provides offline-first data access by querying the local SQLite
+ * database that PowerSync keeps synchronized with Supabase.
+ */
+
+/**
+ * Handler interface for PowerSync watch callbacks.
+ */
+interface WatchHandler {
+    onResult: (results: {
+        rows?: {
+            _array: Record<string, unknown>[];
+        };
+    }) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Options for PowerSync watch operations.
+ */
+interface SQLWatchOptions {
+    signal?: AbortSignal;
+    tables?: string[];
+    throttleMs?: number;
+}
+/**
+ * Extended PowerSync database interface that includes watch functionality.
+ * This extends the base interface from the executor to add reactive query support.
+ *
+ * The watch method is optional to maintain backward compatibility with databases
+ * that don't support reactive queries. When not available, subscribe will fall
+ * back to polling.
+ */
+interface PowerSyncDatabase {
+    getAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
+    get<T>(sql: string, params?: unknown[]): Promise<T | null>;
+    execute(sql: string, params?: unknown[]): Promise<{
+        rowsAffected: number;
+    }>;
+    /**
+     * Watch a SQL query for changes.
+     * Executes the query and invokes the handler whenever the underlying data changes.
+     * Optional - if not available, subscribe will fall back to polling.
+     */
+    watch?(sql: string, parameters?: unknown[], handler?: WatchHandler, options?: SQLWatchOptions): void;
+}
+/**
+ * PowerSyncAdapter implements the TableDataAdapter interface by delegating
+ * all operations to the QueryExecutor.
+ *
+ * @example
+ * const adapter = createPowerSyncAdapter(powerSyncDb, schema);
+ *
+ * // Query with filtering and pagination
+ * const { data, count } = await adapter.query<EquipmentUnit>("EquipmentUnit", {
+ *   where: { status: "active" },
+ *   orderBy: [{ field: "name", direction: "asc" }],
+ *   limit: 10
+ * });
+ *
+ * // Query with relations
+ * const { data } = await adapter.query<EquipmentUnitWithRelations>("EquipmentUnit", {
+ *   select: "*, EquipmentFixture(*), ProjectDatabase(name)"
+ * });
+ */
+/**
+ * Function type for resolving table names to PowerSync aliases.
+ * Used to map schema-qualified names like "core.Profile" to aliases like "CoreProfile".
+ */
+type TableNameResolver = (table: string) => string;
+declare class PowerSyncAdapter implements TableDataAdapter, CapableDataAdapter {
+    private db;
+    private schema;
+    /**
+     * Unique identifier for this adapter type
+     */
+    readonly name = "powersync";
+    /**
+     * Capabilities supported by this adapter
+     */
+    readonly capabilities: AdapterCapabilities;
+    /**
+     * The underlying query executor
+     */
+    private executor;
+    /**
+     * Optional custom table name resolver.
+     * If not provided, uses default auto-alias generation.
+     */
+    private tableNameResolver?;
+    /**
+     * Create a new PowerSyncAdapter
+     *
+     * @param db - PowerSync database instance
+     * @param schema - Database schema for relationship resolution
+     * @param tableNameResolver - Optional custom resolver for table names to PowerSync aliases
+     */
+    constructor(db: PowerSyncDatabase, schema: DatabaseSchema, tableNameResolver?: TableNameResolver);
+    /**
+     * Resolve a table name to its PowerSync alias.
+     * Schema-qualified names like "chat.Conversation" become "Conversation" (schema stripped).
+     * Unqualified names pass through unchanged.
+     *
+     * @param table - Original table name (may be schema-qualified)
+     * @returns The PowerSync alias to use in SQLite queries
+     */
+    private resolveTableName;
+    /**
+     * Execute a query and return results with optional count for pagination.
+     *
+     * @param table - The table name to query
+     * @param options - Query options (select, where, orderBy, limit, offset)
+     * @returns Promise resolving to query results with optional count
+     */
+    query<T>(table: string, options?: QueryOptions): Promise<AdapterQueryResult<T>>;
+    /**
+     * Query a single record by ID.
+     *
+     * @param table - The table name to query
+     * @param id - The record ID
+     * @param options - Optional query options (mainly for select)
+     * @returns Promise resolving to the record or null if not found
+     */
+    queryById<T>(table: string, id: string, options?: Pick<QueryOptions, "select">): Promise<T | null>;
+    /**
+     * Subscribe to changes on a query using PowerSync's native watch() API.
+     *
+     * This uses PowerSync's reactive query watching which efficiently detects
+     * changes to the underlying data and re-executes the query only when needed.
+     *
+     * If the database doesn't support watch(), falls back to polling every 5 seconds.
+     *
+     * @param table - The table name to watch
+     * @param options - Query options to filter what to watch
+     * @param callback - Function called with updated data
+     * @returns Unsubscribe function
+     */
+    subscribe<T>(table: string, options: QueryOptions, callback: (data: T[]) => void): () => void;
+    /**
+     * Fallback polling-based subscription for databases that don't support watch().
+     *
+     * @internal
+     */
+    private subscribeWithPolling;
+    /**
+     * Insert a new record.
+     *
+     * @param table - The table name
+     * @param data - The data to insert
+     * @returns Promise resolving to the inserted record
+     */
+    insert<T>(table: string, data: Partial<T>): Promise<T>;
+    /**
+     * Update an existing record by ID.
+     *
+     * @param table - The table name
+     * @param id - The record ID to update
+     * @param data - The data to update
+     * @returns Promise resolving to the updated record
+     */
+    update<T>(table: string, id: string, data: Partial<T>): Promise<T>;
+    /**
+     * Upsert (insert or update) a record.
+     * If the record has an ID and exists, it will be updated.
+     * Otherwise, a new record will be inserted.
+     *
+     * @param table - The table name
+     * @param data - The data to upsert
+     * @returns Promise resolving to the upserted record
+     */
+    upsert<T>(table: string, data: Partial<T>): Promise<T>;
+    /**
+     * Delete a record by ID.
+     *
+     * @param table - The table name
+     * @param id - The record ID to delete
+     * @returns Promise that resolves when deletion is complete
+     */
+    delete(table: string, id: string): Promise<void>;
+    /**
+     * Get the underlying QueryExecutor for advanced use cases.
+     *
+     * This allows direct access to the executor for operations that
+     * may not be covered by the TableDataAdapter interface.
+     *
+     * @returns The QueryExecutor instance
+     */
+    getExecutor(): QueryExecutor;
+    /**
+     * Get the raw PowerSync database for advanced use cases.
+     *
+     * This allows direct SQL execution when the adapter methods
+     * are not sufficient.
+     *
+     * @returns The PowerSyncDatabase instance
+     */
+    getDatabase(): PowerSyncDatabase;
+    /**
+     * Get the database schema.
+     *
+     * @returns The DatabaseSchema used for relationship resolution
+     */
+    getSchema(): DatabaseSchema;
+}
+/**
+ * Create a new PowerSyncAdapter instance.
+ *
+ * This is the recommended way to create a PowerSyncAdapter as it provides
+ * a cleaner API and allows for future enhancements without breaking changes.
+ *
+ * @param db - PowerSync database instance
+ * @param schema - Database schema for relationship resolution
+ * @returns A new PowerSyncAdapter instance
+ *
+ * @example
+ * import { createPowerSyncAdapter } from "./adapters/powersync-adapter";
+ *
+ * const adapter = createPowerSyncAdapter(powerSyncDb, databaseSchema);
+ *
+ * // Use the adapter
+ * const { data } = await adapter.query("EquipmentUnit", {
+ *   where: { status: "active" }
+ * });
+ */
+declare function createPowerSyncAdapter(db: PowerSyncDatabase, schema: DatabaseSchema): PowerSyncAdapter;
+
+/**
+ * V3 Data Layer Provider
+ *
+ * React context provider that initializes adapters, manages the PowerSync lifecycle,
+ * and provides context for all V3 hooks. This is the main entry point for the V3
+ * data layer in a React application.
+ */
+
+/**
+ * Props for DataLayerProvider
+ */
+interface DataLayerProviderProps {
+    /** Data layer configuration */
+    config: DataLayerConfig;
+    /** Children to render */
+    children: ReactNode;
+    /**
+     * 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;
+    /** React Query client (required) */
+    queryClient: QueryClient;
+    /** Callback when initialization completes */
+    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.
+ *
+ * This provider:
+ * - Creates and manages the AdapterRegistry
+ * - Initializes the AdapterAutoDetector for backend selection
+ * - Sets up Supabase and PowerSync adapters
+ * - Tracks online/offline status
+ * - Provides context for all V3 hooks
+ *
+ * @example
+ * ```tsx
+ * import { DataLayerProvider } from "@pol-studios/db";
+ *
+ * function App() {
+ *   return (
+ *     <DataLayerProvider
+ *       config={dataLayerConfig}
+ *       supabaseClient={supabase}
+ *       queryClient={queryClient}
+ *       powerSyncInstance={powerSyncDb}
+ *     >
+ *       <YourApp />
+ *     </DataLayerProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function DataLayerProvider({ config, children, powerSyncInstance, supabaseClient, queryClient, onInitialized, onError, powerSyncSyncStatus, }: DataLayerProviderProps): JSX.Element;
+
+interface FileWithPreview extends File {
+    preview?: string;
+    errors: readonly FileError[];
+}
+type UseSupabaseUploadOptions = {
+    /**
+     * Name of bucket to upload files to in your Supabase project
+     */
+    bucketName: string;
+    /**
+     * Folder to upload files to in the specified bucket within your Supabase project.
+     *
+     * Defaults to uploading files to the root of the bucket
+     *
+     * e.g If specified path is `test`, your file will be uploaded as `test/file_name`
+     */
+    path?: string;
+    /**
+     * Allowed MIME types for each file upload (e.g `image/png`, `text/html`, etc). Wildcards are also supported (e.g `image/*`).
+     *
+     * Defaults to allowing uploading of all MIME types.
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * Maximum upload size of each file allowed in bytes. (e.g 1000 bytes = 1 KB)
+     */
+    maxFileSize?: number;
+    /**
+     * Maximum number of files allowed per upload.
+     */
+    maxFiles?: number;
+    /**
+     * The number of seconds the asset is cached in the browser and in the Supabase CDN.
+     *
+     * This is set in the Cache-Control: max-age=<seconds> header. Defaults to 3600 seconds.
+     */
+    cacheControl?: number;
+    /**
+     * When set to true, the file is overwritten if it exists.
+     *
+     * When set to false, an error is thrown if the object already exists. Defaults to `false`
+     */
+    upsert?: boolean;
+};
+type UseSupabaseUploadReturn = ReturnType<typeof useSupabaseUpload>;
+declare const useSupabaseUpload: (options: UseSupabaseUploadOptions) => {
+    open: () => void;
+    isFocused: boolean;
+    isDragActive: boolean;
+    isDragAccept: boolean;
+    isDragReject: boolean;
+    isFileDialogActive: boolean;
+    acceptedFiles: readonly react_dropzone.FileWithPath[];
+    fileRejections: readonly FileRejection[];
+    rootRef: React.RefObject<HTMLElement>;
+    inputRef: React.RefObject<HTMLInputElement>;
+    getRootProps: <T extends react_dropzone.DropzoneRootProps>(props?: T) => T;
+    getInputProps: <T extends react_dropzone.DropzoneInputProps>(props?: T) => T;
+    files: FileWithPreview[];
+    setFiles: react.Dispatch<react.SetStateAction<FileWithPreview[]>>;
+    successes: string[];
+    isSuccess: boolean;
+    loading: boolean;
+    errors: {
+        name: string;
+        message: string;
+    }[];
+    setErrors: react.Dispatch<react.SetStateAction<{
+        name: string;
+        message: string;
+    }[]>>;
+    onUpload: () => Promise<void>;
+    maxFileSize: number;
+    maxFiles: number;
+    allowedMimeTypes: string[];
+};
+
+/**
+ * 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.
+ *
+ * Wrap your app with this provider to enable conflict detection and resolution.
+ *
+ * @example
+ * ```tsx
+ * <PowerSyncProvider connector={connector}>
+ *   <ConflictProvider>
+ *     <App />
+ *   </ConflictProvider>
+ * </PowerSyncProvider>
+ * ```
+ */
+declare function ConflictProvider({ children, conflictBus }: ConflictProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Conflict State Hooks for @pol-studios/db
+ *
+ * Provides hooks for accessing and filtering conflict state.
+ */
+
+/**
+ * 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();
+ *
+ *   return (
+ *     <View>
+ *       <Text>{pendingConflicts.length} conflicts pending</Text>
+ *       <Button onPress={() => resolveAll({ action: 'keep-server' })}>
+ *         Accept All Server Changes
+ *       </Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useConflictState(): ConflictContextValue;
+/**
+ * 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
+ *
+ * @example
+ * ```tsx
+ * function ConflictBadge() {
+ *   const conflicts = usePendingConflicts();
+ *   if (conflicts.length === 0) return null;
+ *   return <Badge count={conflicts.length} />;
+ * }
+ * ```
+ */
+declare function usePendingConflicts(): ConflictCheckResult[];
+/**
+ * Hook to check if there are any pending conflicts.
+ *
+ * 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 useHasConflicts(): boolean;
+/**
+ * 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.
+ */
+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, 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 };