@pol-studios/db 1.0.19 → 1.0.22

package/dist/hooks/index.d.ts

@@ -0,0 +1,119 @@
+export { C as ClarificationQuestion, D as DatabaseTypes, F as Filter, x as FilterGroup, y as FilterOperator, z as Pagination, P as PublicTableNames, Q as QueryState, R as ResolveRowType, S as SchemaNames, l as SchemaTableNames, A as Sort, T as TableIdentifier, U as UseAdvanceQueryOptions, m as UseAdvanceQueryResult, n as UseDbCountOptions, o as UseDbCountResult, K as UseDbDeleteOptions, L as UseDbDeleteResult, p as UseDbInfiniteQueryOptions, q as UseDbInfiniteQueryResult, B as UseDbInsertOptions, E as UseDbInsertResult, v as UseDbQueryByIdOptions, w as UseDbQueryByIdResult, r as UseDbQueryOptions, s as UseDbQueryResult, G as UseDbUpdateOptions, H as UseDbUpdateResult, I as UseDbUpsertOptions, J as UseDbUpsertResult, u as useAdvanceQuery, a as useDataLayer, b as useDataLayerCore, t as useDataLayerOptional, c as useDataLayerStatus, d as useDbCount, e as useDbDelete, f as useDbInfiniteQuery, g as useDbInsert, h as useDbQuery, i as useDbQueryById, j as useDbUpdate, k as useDbUpsert } from '../useDbCount-s-aR9YeV.js';
+import { SyncStatus, SyncControl } from '../core/index.js';
+import '../DataLayerContext-ZmLPYR_s.js';
+import 'react';
+import '@supabase/supabase-js';
+import '@tanstack/react-query';
+import '../executor-CB4KHyYG.js';
+
+/**
+ * V3 useSyncStatus Hook
+ *
+ * Provides sync status information from the data layer.
+ * Returns default "always synced" status when PowerSync is not available.
+ *
+ * Uses the split context architecture for optimal performance.
+ */
+
+/**
+ * Hook to get the current sync status
+ *
+ * When PowerSync is not available, returns a default "always synced" status.
+ *
+ * This hook uses the split context architecture - it only subscribes to
+ * status changes, not core value changes.
+ *
+ * @example
+ * const { isSyncing, pendingUploads, isConnected } = useSyncStatus();
+ *
+ * if (pendingUploads > 0) {
+ *   console.log(`${pendingUploads} changes waiting to sync`);
+ * }
+ */
+declare function useSyncStatus(): SyncStatus;
+
+/**
+ * V3 useSyncControl Hook
+ *
+ * Provides sync control functions from the data layer.
+ * Returns no-op functions when PowerSync is not available.
+ *
+ * Uses the split context architecture for optimal performance.
+ */
+
+/**
+ * Hook to get sync controls for PowerSync
+ *
+ * When PowerSync is not available, all methods are no-ops that log a warning.
+ *
+ * This hook uses the split context architecture - it subscribes to both
+ * status (for syncControl) and core (for powerSync instance check).
+ *
+ * @example
+ * const { triggerSync, startLiveSync, stopLiveSync } = useSyncControl();
+ *
+ * // Manually trigger a sync
+ * await triggerSync();
+ *
+ * // Start/stop live sync
+ * await startLiveSync();
+ * stopLiveSync();
+ *
+ * @example Failed upload controls
+ * const {
+ *   failedUploads,
+ *   retryFailedUploads,
+ *   clearFailedUploads,
+ *   pauseAutoRetry,
+ *   resumeAutoRetry,
+ *   isAutoRetryPaused
+ * } = useSyncControl();
+ *
+ * // Show failed uploads count
+ * console.log(`${failedUploads.length} uploads failed`);
+ *
+ * // Manually retry all failed uploads
+ * await retryFailedUploads();
+ *
+ * // Discard all failed uploads
+ * clearFailedUploads();
+ */
+declare function useSyncControl(): SyncControl;
+
+/**
+ * V3 useOnlineStatus Hook
+ *
+ * Provides online/connection status information.
+ * Uses DataLayerProvider's status as the SINGLE source of truth.
+ *
+ * On React Native: status.isOnline comes from PowerSync platform adapter (NetInfo)
+ * On Web: status.isOnline comes from browser navigator.onLine
+ */
+/**
+ * Online status information
+ */
+interface OnlineStatus {
+    /** Whether the device has network connectivity */
+    isOnline: boolean;
+    /** Whether PowerSync is connected (false if using Supabase-only) */
+    isConnected: boolean;
+    /** Current backend being used */
+    backend: "powersync" | "supabase" | null;
+}
+/**
+ * Hook to get online/connection status
+ *
+ * Uses DataLayerProvider's status as the single source of truth:
+ * - On React Native: isOnline comes from PowerSync platform adapter (NetInfo)
+ * - On Web: isOnline comes from browser navigator.onLine
+ *
+ * @example
+ * const { isOnline, isConnected, backend } = useOnlineStatus();
+ *
+ * if (!isOnline) {
+ *   return <OfflineBanner />;
+ * }
+ */
+declare function useOnlineStatus(): OnlineStatus;
+
+export { type OnlineStatus, useOnlineStatus, useSyncControl, useSyncStatus };

package/dist/hooks/index.js

@@ -15,7 +15,7 @@ import {
   useOnlineStatus,
   useSyncControl,
   useSyncStatus
-} from "../chunk-YERWPV6B.js";
+} from "../chunk-3FHAKRDV.js";
 import "../chunk-GC3TBUWE.js";
 import "../chunk-J4ZVCXZ4.js";
 import "../chunk-OQ7U6EQ3.js";

package/dist/index-2YySlz7X.d.ts

@@ -0,0 +1,433 @@
+import { V as ValueForPropertyType, P as PropertyType, a as FilterConfig } from './FilterConfig-Bt2Ek74z.js';
+import { Moment } from 'moment';
+import './database.types-ChFCG-4M.js';
+import { PostgrestSingleResponse, SupabaseClient } from '@supabase/supabase-js';
+import { Dispatch, SetStateAction } from 'react';
+import { UseQueryOptions, DefinedUseQueryResult, QueryClient } from '@tanstack/react-query';
+import { SyncControl, SyncStatus, DataLayerConfig } from './core/index.js';
+import { s as DataLayerStatus, p as DataLayerContextValue } from './DataLayerContext-ZmLPYR_s.js';
+
+/**
+ * Represents a change log entry for database records.
+ * Used for tracking live changes to entities.
+ */
+interface DbChangeLog {
+    modifiedByUserId: string;
+    changedOn: Moment;
+    changes: Record<string, unknown>;
+}
+
+declare const normalizeFilter: (filter: FilterInput) => Filter | FilterGroup | null;
+/**
+ * Filter state for the UI - extends Filter with UI-specific metadata.
+ * FilterState can always be assigned where Filter is expected since it
+ * contains all Filter properties. The omitted properties (similarity, where, options)
+ * are AI search-specific and not typically needed in the UI filter state.
+ */
+interface FilterState extends Omit<Filter, 'similarity' | 'where' | 'options'> {
+}
+type ValueOrArrayForPropertyType<T extends PropertyType> = ValueForPropertyType<T> | ValueForPropertyType<T>[];
+type BooleanOperator = "AND" | "OR";
+/**
+ * Filter operators supported by the edge function.
+ * This is the single source of truth - matches /supabase/functions/_shared/query-sdk/types.ts
+ *
+ * Note: The following operators are normalized by normalizeFilter() before sending to the server:
+ * - "like" -> "contains"
+ * - "regex", "regex_i", "similar_to" -> "contains"
+ * - "!=" and "<>" are NOT supported - use "=" with not: true instead
+ */
+type FilterOperator = "=" | ">" | ">=" | "<" | "<=" | "contains" | "ilike" | "is" | "in" | "ai_search";
+type FilterConditionType = FilterOperator;
+/**
+ * Filter interface - matches edge function API
+ */
+interface Filter {
+    /** Unique identifier */
+    id: string;
+    /** Field to filter on */
+    field: string;
+    /** Operator */
+    op: FilterOperator;
+    /** Value to compare */
+    value: string | number | string[] | number[] | boolean | null;
+    /** Negate the condition */
+    not?: boolean;
+    /** AI search options (when op = "ai_search") */
+    similarity?: number;
+    where?: string;
+    display?: string;
+    options?: {
+        display: string;
+        value: ValueForPropertyType<PropertyType>;
+    }[];
+    /** Filter configuration (UI metadata) */
+    info?: FilterConfig<any>;
+}
+/**
+ * Filter group - combine multiple filters
+ */
+interface FilterGroup {
+    /** Unique identifier */
+    id: string;
+    /** How to combine filters */
+    op: "AND" | "OR";
+    /** Filters in this group */
+    filters: Array<Filter | FilterGroup>;
+    /** Negate the entire group (NOT (A AND B)) */
+    not?: boolean;
+}
+/**
+ * Input type for normalizeFilter - accepts both legacy and new filter formats.
+ * The normalizeFilter function handles legacy operators (like, regex, etc.) for data migration,
+ * but the type only exposes the supported FilterOperator values.
+ */
+type FilterInput = {
+    id?: string;
+    field?: string;
+    value?: string | number | string[] | number[] | boolean | null;
+    not?: boolean;
+    similarity?: number;
+    where?: string;
+    display?: string;
+    options?: {
+        display: string;
+        value: ValueForPropertyType<PropertyType>;
+    }[];
+    filters?: Array<Filter | FilterGroup | FilterInput>;
+    op?: FilterOperator | "AND" | "OR";
+    propertyName?: string;
+    condition?: string;
+    operator?: "AND" | "OR";
+    inverted?: boolean;
+};
+/**
+ * Pagination settings
+ */
+interface Pagination {
+    offset?: number;
+    limit?: number;
+}
+/**
+ * Configuration for computed/aggregated field sorting
+ */
+interface ComputedSortConfig {
+    /** Aggregation function to apply */
+    fn: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX";
+    /** Field to aggregate */
+    field: string;
+    /** Relationship path for related table aggregation (e.g., "OrderItem" or "Order.OrderItem") */
+    relationship?: string;
+}
+/**
+ * Sort order
+ */
+interface Sort {
+    field: string;
+    direction: "asc" | "desc";
+    /** Optional computed/aggregated sort configuration for sorting by aggregate values */
+    computed?: ComputedSortConfig;
+}
+/**
+ * Query state that includes FilterGroup plus pagination, sort, and isReady
+ * Used by useDbAdvanceFilterQuery for managing filter state with query metadata
+ */
+interface QueryState extends FilterGroup {
+    /** Pagination settings */
+    pagination?: Pagination;
+    /** Sort order */
+    sort?: Sort[];
+    /** Distinct ON expressions - returns one record per unique combination */
+    distinctOn?: string[];
+    /** Natural language query - converts to filters automatically */
+    naturalLanguageQuery?: string;
+    /** Whether the query is ready to execute */
+    isReady: boolean;
+}
+interface ClarificationSuggestion {
+    interpretation: string;
+    field_path: string;
+    example: string;
+    confidence: number;
+}
+interface ClarificationQuestion {
+    question: string;
+    suggestions: ClarificationSuggestion[];
+}
+interface FilterContextType<T> {
+    filters: FilterGroup;
+    setFilters: Dispatch<SetStateAction<FilterGroup>>;
+}
+interface OrderColumn {
+    field: string;
+    direction: "asc" | "desc";
+}
+declare function useDbAdvanceFilterQuery<Result>(query: PromiseLike<PostgrestSingleResponse<Result>>, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>>, "queryKey" | "queryFn"> & {
+    key?: string;
+    filterKey?: string;
+    searchByDefault?: boolean;
+    timeout?: number;
+    count?: "exact" | "estimated" | "";
+}): [
+    DefinedUseQueryResult<Result, Error> & {
+        count: number;
+        clarification?: ClarificationQuestion;
+    },
+    QueryState,
+    Dispatch<SetStateAction<QueryState>>
+];
+
+/**
+ * PowerSync Integration Types for @pol-studios/db
+ *
+ * This module provides TypeScript types for integrating the @pol-studios/db
+ * package with @pol-studios/powersync. These types enable type-safe configuration
+ * and context access when using both packages together.
+ */
+
+/**
+ * Extended DataLayerConfig with PowerSync-specific options.
+ *
+ * Use this type when you want to configure the data layer to work
+ * optimally with @pol-studios/powersync.
+ *
+ * @template DB - The database types (from generated types)
+ */
+interface PowerSyncEnabledConfig<DB = unknown> extends DataLayerConfig<DB> {
+    /**
+     * PowerSync-specific configuration options.
+     */
+    powerSync?: {
+        /**
+         * Whether to prefer PowerSync when both backends are available.
+         * @default true
+         */
+        preferPowerSync?: boolean;
+        /**
+         * Whether to automatically reconnect on network changes.
+         * @default true
+         */
+        autoReconnect?: boolean;
+        /**
+         * Tables that should always use Supabase directly (bypass PowerSync).
+         * Useful for tables with real-time requirements or very large data.
+         */
+        supabaseOnlyTables?: string[];
+        /**
+         * Tables that should prioritize local data freshness over sync.
+         * These tables will be queried from PowerSync first without waiting for sync.
+         */
+        offlineFirstTables?: string[];
+    };
+}
+/**
+ * Enhanced sync status that includes PowerSync-specific details.
+ *
+ * This type extends the base SyncStatus with additional information
+ * available when using @pol-studios/powersync.
+ */
+interface EnhancedSyncStatus extends SyncStatus {
+    /**
+     * Whether the initial sync has completed.
+     * Data may be stale until this is true.
+     */
+    hasSynced?: boolean;
+    /**
+     * Download progress during initial sync or re-sync.
+     */
+    downloadProgress?: {
+        /** Number of operations downloaded so far */
+        current: number;
+        /** Total number of operations to download */
+        target: number;
+        /** Percentage complete (0-100) */
+        percentage: number;
+    };
+    /**
+     * Connection health status when available.
+     */
+    connectionHealth?: {
+        /** Current connection status */
+        status: "healthy" | "degraded" | "disconnected";
+        /** Last measured query latency in milliseconds */
+        latency: number | null;
+    };
+}
+/**
+ * Enhanced sync control with PowerSync-specific actions.
+ */
+interface EnhancedSyncControl extends SyncControl {
+    /**
+     * Pause sync operations.
+     * The database remains accessible but won't sync with the server.
+     */
+    pause?: () => Promise<void>;
+    /**
+     * Resume sync operations after pausing.
+     */
+    resume?: () => Promise<void>;
+    /**
+     * Disconnect from the PowerSync service entirely.
+     */
+    disconnect?: () => Promise<void>;
+}
+/**
+ * Extended DataLayerContextValue with PowerSync integration.
+ *
+ * This type provides additional context values available when
+ * PowerSync is being used as the backend.
+ */
+interface PowerSyncEnabledContextValue extends DataLayerContextValue {
+    /**
+     * Enhanced sync status with PowerSync details.
+     */
+    syncStatus: EnhancedSyncStatus;
+    /**
+     * Enhanced sync control with PowerSync actions.
+     */
+    syncControl: EnhancedSyncControl;
+    /**
+     * Whether PowerSync is the active backend.
+     */
+    isPowerSyncActive: boolean;
+    /**
+     * Connection health metrics (only available with PowerSync).
+     */
+    connectionHealth?: {
+        status: "healthy" | "degraded" | "disconnected";
+        latency: number | null;
+        lastHealthCheck: Date | null;
+    };
+    /**
+     * Sync metrics (only available with PowerSync).
+     */
+    syncMetrics?: {
+        totalSyncs: number;
+        successfulSyncs: number;
+        failedSyncs: number;
+        lastSyncDuration: number | null;
+        averageSyncDuration: number | null;
+    };
+}
+/**
+ * Props for using DataLayerProvider with PowerSync.
+ *
+ * This type defines the shape of props when integrating DataLayerProvider
+ * with values from PowerSyncProvider.
+ *
+ * @template DB - The database types
+ */
+interface DataLayerWithPowerSyncProps<DB = unknown> {
+    /**
+     * Data layer configuration.
+     */
+    config: PowerSyncEnabledConfig<DB>;
+    /**
+     * Children to render.
+     */
+    children: React.ReactNode;
+    /**
+     * PowerSync database instance from PowerSyncProvider.
+     * Pass this from usePowerSync().db
+     */
+    powerSyncInstance: unknown | null;
+    /**
+     * Supabase client (required).
+     */
+    supabaseClient: SupabaseClient;
+    /**
+     * React Query client (required).
+     */
+    queryClient: QueryClient;
+    /**
+     * Optional callback when initialization completes.
+     */
+    onInitialized?: (context: DataLayerContextValue) => void;
+    /**
+     * Optional callback when error occurs.
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Return type for useDataLayer when PowerSync is available.
+ */
+type UseDataLayerWithPowerSync = PowerSyncEnabledContextValue;
+/**
+ * Return type for useSyncStatus when PowerSync is available.
+ */
+type UseSyncStatusWithPowerSync = EnhancedSyncStatus;
+/**
+ * Return type for useSyncControl when PowerSync is available.
+ */
+type UseSyncControlWithPowerSync = EnhancedSyncControl;
+/**
+ * Type helper to check if PowerSync is configured in a config.
+ */
+type HasPowerSyncConfig<T> = T extends {
+    powerSync: object;
+} ? true : false;
+/**
+ * Type helper to extract PowerSync tables from config.
+ */
+type PowerSyncTables<Config> = Config extends PowerSyncEnabledConfig ? Exclude<keyof Config["tables"], Config["powerSync"] extends {
+    supabaseOnlyTables: infer T;
+} ? T extends readonly string[] ? T[number] : never : never> : keyof Config extends {
+    tables: infer T;
+} ? keyof T : never;
+/**
+ * Backend selection result type.
+ */
+interface BackendSelectionResult {
+    /**
+     * The selected backend for the operation.
+     */
+    backend: "powersync" | "supabase";
+    /**
+     * Reason for the selection.
+     */
+    reason: "powersync_available" | "powersync_preferred" | "offline" | "supabase_only_table" | "powersync_not_ready" | "fallback";
+}
+/**
+ * Combined status from both DataLayer and PowerSync providers.
+ */
+interface CombinedProviderStatus {
+    /**
+     * DataLayer initialization status.
+     */
+    dataLayer: DataLayerStatus;
+    /**
+     * PowerSync readiness status.
+     */
+    powerSync: {
+        isReady: boolean;
+        isInitializing: boolean;
+        error: Error | null;
+    };
+    /**
+     * Overall status.
+     */
+    overall: {
+        /**
+         * True when both providers are ready.
+         */
+        isReady: boolean;
+        /**
+         * True when either provider is initializing.
+         */
+        isInitializing: boolean;
+        /**
+         * First error from either provider.
+         */
+        error: Error | null;
+    };
+}
+/**
+ * Creates a combined status from DataLayer and PowerSync status.
+ */
+declare function createCombinedStatus(dataLayerStatus: DataLayerStatus, powerSyncStatus: {
+    isReady: boolean;
+    isInitializing: boolean;
+    error: Error | null;
+}): CombinedProviderStatus;
+
+export { type BooleanOperator as B, type CombinedProviderStatus as C, type DbChangeLog as D, type EnhancedSyncControl as E, type FilterOperator as F, type HasPowerSyncConfig as H, type OrderColumn as O, type PowerSyncEnabledConfig as P, type QueryState as Q, type Sort as S, type UseDataLayerWithPowerSync as U, type ValueOrArrayForPropertyType as V, type EnhancedSyncStatus as a, type PowerSyncEnabledContextValue as b, createCombinedStatus as c, type FilterConditionType as d, type Filter as e, type FilterGroup as f, type FilterInput as g, type FilterState as h, type Pagination as i, type ComputedSortConfig as j, type ClarificationSuggestion as k, type ClarificationQuestion as l, type FilterContextType as m, type DataLayerWithPowerSyncProps as n, type UseSyncStatusWithPowerSync as o, type UseSyncControlWithPowerSync as p, type PowerSyncTables as q, type BackendSelectionResult as r, normalizeFilter as s, useDbAdvanceFilterQuery as u };

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+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, E as EnhancedSyncControl, a 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 } from './index-2YySlz7X.js';
+export { A as AIOptions, k as AIResponse, y as AlertProps, B as BUCKETS, v as BucketName, C as CustomPageQueryResult, D as DEFAULT_QUERY_TIMEOUT, Y as FeedbackListItem, Z as FeedbackListParams, L as LiveChangeContext, z as LiveChangeContextProvider, m as ServerAvailabilityState, t as StorageObjectMetadata, $ as SubmitFeedbackParams, S as SupabaseAdapter, T as TIMEOUT_ERROR_MESSAGE, q as UpdateOptions, U as UseMutationSuccessOptions, w as createInCondition, i as createSupabaseAdapter, r as executeAdvanceQuery, j as getErrorBody, g as getSupabaseUrl, x as isTimeoutError, n as newTimeActivity, s as setSupabaseUrl, l as useAI, a0 as useApplyFeedback, b as useAutosaveState, Q as useChangelogById, R as useChangelogBySlug, V as useChangelogEntries, W as useChangelogMedia, O as useChangelogs, F as useDeleteChangelog, I as useDeleteChangelogEntry, M as useDeleteChangelogMedia, X as useFeedbackList, a as useLatestOperationLog, u as useLiveChangeTracking, J as useMultiDeleteChangelogEntries, H as useMultiUpsertChangelogEntries, f as useMutationSuccess, h as useMutationSuccessRN, P as usePublishedChangelogs, a1 as useResolveFeedback, p as useSearchQuery, o as useServerAvailability, e as useStoragePath, d as useStorageUrl, _ as useSubmitFeedback, c as useToastError, N as useUploadChangelogMedia, E as useUpsertChangelog, G as useUpsertChangelogEntry, K as useUpsertChangelogMedia } from './useResolveFeedback-DTGcHpCs.js';
+export { u as useBatchDelete, a as useBatchUpsert } from './useBatchUpsert-9OYjibLh.js';
+export { AdapterRegistry as AdapterRegistryInterface, AutoStrategy, BuiltQuery, CachedStrategy, ColumnInfo, ColumnType, ConnectionConfig, DataAdapter, DataLayerConfig, DataLayerHooks, DatabaseSchema, DeleteMutationResult, ExtractInsert, ExtractRow, ExtractUpdate, FailedUpload, HybridStrategy, MutationHookResult, MutationResult, OrderBy, ParsedSelect, PowerSyncStrategy, QueryOptions, 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 { f as ADAPTER_STRATEGIES, i as AdapterAutoDetector, c as AdapterCapabilities, a as AdapterConfig, d as AdapterDependencies, b as AdapterFactory, A as AdapterQueryResult, g as AdapterRegistry, e as AdapterStrategyType, k as AutoDetectionResult, l as AutoDetectorOptions, m as BackendChangeListener, B as BackendStatus, C as CapableDataAdapter, D as DataLayerContext, p as DataLayerContextValue, n as DataLayerCoreContext, q as DataLayerCoreContextValue, s as DataLayerStatus, o as DataLayerStatusContext, r as DataLayerStatusContextValue, S as SyncStatusInfo, T as TableDataAdapter, j as createAdapterAutoDetector, h as createAdapterRegistry } from './DataLayerContext-ZmLPYR_s.js';
+export { ConflictCheckResult, ConflictContext, ConflictContextValue, ConflictProvider, ConflictProviderProps, ConflictResolution, DataLayerProvider, DataLayerProviderProps, FieldConflict, PowerSyncAdapter, UseConflictResolutionReturn, UseSupabaseUploadOptions, UseSupabaseUploadReturn, createPowerSyncAdapter, useBulkConflictResolution, useConflictCountByTable, useConflictForRecord, useConflictResolution, useConflictState, useConflictsForTable, useHasConflicts, usePendingConflicts, useSupabaseUpload } from './index.native.js';
+export { D as DatabaseTypes, P as PublicTableNames, R as ResolveRowType, S as SchemaNames, l as SchemaTableNames, T as TableIdentifier, U as UseAdvanceQueryOptions, m as UseAdvanceQueryResult, n as UseDbCountOptions, o as UseDbCountResult, p as UseDbInfiniteQueryOptions, q as UseDbInfiniteQueryResult, r as UseDbQueryOptions, s as UseDbQueryResult, u as useAdvanceQuery, a as useDataLayer, b as useDataLayerCore, c as useDataLayerStatus, d as useDbCount, d as useDbCountV3, e as useDbDelete, f as useDbInfiniteQuery, f as useDbInfiniteQueryV3, g as useDbInsert, h as useDbQuery, i as useDbQueryById, j as useDbUpdate, k as useDbUpsert } from './useDbCount-s-aR9YeV.js';
+export { useOnlineStatus, useSyncControl, useSyncStatus } from './hooks/index.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 { B as BatchAnalysisProgress, E as ExtractedReceipt, P as PendingExpense, a as useReceiptAI, u as useSupabaseFunction } from './useReceiptAI-6HkRpRml.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';
+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 { 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 { 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';
+export { AbstractPowerSyncDatabase, PowerSyncConnectionHealth, PowerSyncControlActions, PowerSyncIntegrationOptions, PowerSyncMetrics, PowerSyncSyncStatus, convertToDataLayerSyncControl, convertToDataLayerSyncStatus, getPowerSyncInstance, isAbstractPowerSyncDatabase, isPowerSyncAvailable } from './powersync-bridge/index.js';
+import 'moment';
+import '@supabase/supabase-js';
+import 'react';
+import '@tanstack/react-query';
+import '@supabase/functions-js';
+import '@supabase/postgrest-js';
+import './useDbQuery-C-TL8jY1.js';
+import '@pol-studios/utils';
+import '@supabase-cache-helpers/postgrest-react-query';
+import '@supabase/storage-js';
+import 'react/jsx-runtime';
+import './executor-CB4KHyYG.js';
+import 'react-dropzone';
+import '@supabase/supabase-js/dist/module/lib/types.js';