@pol-studios/db 1.0.0 → 1.0.2

package/dist/useDbCount-B5-Va9sg.d.ts

@@ -0,0 +1,1740 @@
+import * as react from 'react';
+import { Dispatch, SetStateAction } from 'react';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { QueryClient } from '@tanstack/react-query';
+import { DatabaseSchema, QueryOptions, DataLayerConfig, TableStrategy, SyncStatus, SyncControl, WhereClause } from './core/index.js';
+import { P as PowerSyncDatabase } from './executor-CB4KHyYG.js';
+
+/**
+ * V3 Data Layer Adapter Types
+ *
+ * Extended types for the adapter layer that complement the core DataAdapter interface.
+ * These types support the Strategy pattern for routing queries to different backends.
+ */
+
+/**
+ * Result from adapter query operations.
+ * Extends the basic array with optional count for pagination.
+ */
+interface AdapterQueryResult<T> {
+    /** The queried data */
+    data: T[];
+    /** Total count of matching records (for pagination) */
+    count?: number;
+}
+/**
+ * Extended adapter interface that accepts table name for multi-table routing.
+ *
+ * This interface is used by the AdapterRegistry to provide table-aware adapters
+ * that can handle multiple tables with a single adapter instance.
+ *
+ * Differences from core DataAdapter:
+ * - Includes table name parameter in all methods
+ * - Returns AdapterQueryResult with optional count
+ * - Supports optional subscribe method for reactivity
+ */
+interface TableDataAdapter {
+    /**
+     * Unique identifier for the adapter type
+     */
+    readonly name: string;
+    /**
+     * Execute a query and return results
+     *
+     * @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 real-time changes on a query.
+     * Not all adapters support this - it's optional.
+     *
+     * @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;
+    /**
+     * 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>;
+}
+/**
+ * Configuration for creating an adapter
+ */
+interface AdapterConfig {
+    /**
+     * The strategy type to create
+     */
+    strategy: "powersync" | "supabase" | "cached" | "hybrid";
+    /**
+     * Additional strategy-specific configuration
+     */
+    [key: string]: unknown;
+}
+/**
+ * Factory interface for creating adapters
+ */
+interface AdapterFactory {
+    /**
+     * Create a new adapter instance based on configuration
+     *
+     * @param config - Adapter configuration
+     * @returns The created adapter instance
+     */
+    create(config: AdapterConfig): TableDataAdapter;
+}
+/**
+ * Describes the capabilities of an adapter
+ */
+interface AdapterCapabilities {
+    /**
+     * Whether the adapter supports real-time subscriptions
+     */
+    supportsSubscribe: boolean;
+    /**
+     * Whether the adapter works offline
+     */
+    supportsOffline: boolean;
+    /**
+     * Whether the adapter caches data locally
+     */
+    supportsCache: boolean;
+    /**
+     * Whether the adapter syncs data bidirectionally
+     */
+    supportsSync: boolean;
+}
+/**
+ * Extended adapter interface with capability reporting
+ */
+interface CapableDataAdapter extends TableDataAdapter {
+    /**
+     * Get the capabilities of this adapter
+     */
+    readonly capabilities: AdapterCapabilities;
+}
+/**
+ * Dependencies required to initialize adapters.
+ * Uses 'unknown' type for external dependencies to allow proper typing
+ * when concrete implementations are provided.
+ */
+interface AdapterDependencies {
+    /**
+     * PowerSync database instance
+     * Will be typed as PowerSyncDatabase when PowerSync is integrated
+     */
+    powerSync: unknown;
+    /**
+     * Supabase client instance
+     * Will be typed as SupabaseClient when imported
+     */
+    supabase: unknown;
+    /**
+     * TanStack Query client for caching
+     * Will be typed as QueryClient when imported
+     */
+    queryClient: unknown;
+    /**
+     * Database schema for relationship resolution
+     */
+    schema: DatabaseSchema;
+}
+/**
+ * String literals for adapter strategy types
+ */
+declare const ADAPTER_STRATEGIES: {
+    readonly POWERSYNC: "powersync";
+    readonly SUPABASE: "supabase";
+    readonly CACHED: "cached";
+    readonly HYBRID: "hybrid";
+    readonly AUTO: "auto";
+};
+
+/**
+ * Type for adapter strategy values
+ */
+type AdapterStrategyType = (typeof ADAPTER_STRATEGIES)[keyof typeof ADAPTER_STRATEGIES];
+
+/**
+ * Adapter Auto-Detector
+ *
+ * Detects available backends (PowerSync, Supabase) at runtime and recommends
+ * the best one to use based on availability and configuration preferences.
+ *
+ * This enables the V3 data layer to automatically select the optimal backend
+ * for offline-first or online-first experiences.
+ */
+
+/**
+ * Status of a backend adapter
+ */
+declare enum BackendStatus {
+    /** Backend is available and ready to use */
+    AVAILABLE = "available",
+    /** Backend is initializing (e.g., PowerSync syncing) */
+    INITIALIZING = "initializing",
+    /** Backend is not available */
+    UNAVAILABLE = "unavailable"
+}
+/**
+ * Result of auto-detection
+ */
+interface AutoDetectionResult {
+    /** PowerSync availability status */
+    powerSyncStatus: BackendStatus;
+    /** Supabase availability status */
+    supabaseStatus: BackendStatus;
+    /** Recommended backend to use */
+    recommendedBackend: "powersync" | "supabase";
+    /** Whether device is online */
+    isOnline: boolean;
+    /** Reason for recommendation */
+    reason: string;
+}
+/**
+ * Options for auto-detection
+ */
+interface AutoDetectorOptions {
+    /** Prefer PowerSync when available (default: true) */
+    preferPowerSync?: boolean;
+    /** Timeout for status checks in ms (default: 1000) */
+    statusCheckTimeout?: number;
+}
+/**
+ * Listener for backend change events
+ */
+type BackendChangeListener = (result: AutoDetectionResult) => void;
+/**
+ * Detects available backends and recommends the best one to use.
+ *
+ * The auto-detector checks for PowerSync and Supabase availability and
+ * makes intelligent recommendations based on:
+ * - Backend availability
+ * - Network connectivity
+ * - User preferences (preferPowerSync option)
+ *
+ * @example
+ * ```typescript
+ * const detector = new AdapterAutoDetector(powerSyncDb, supabaseClient, {
+ *   preferPowerSync: true,
+ * });
+ *
+ * const result = detector.detect();
+ * console.log(`Using ${result.recommendedBackend}: ${result.reason}`);
+ * ```
+ */
+declare class AdapterAutoDetector {
+    private powerSyncDb;
+    private supabase;
+    private options;
+    private listeners;
+    private lastResult;
+    constructor(powerSyncDb: PowerSyncDatabase | null, supabase: SupabaseClient | null, options?: AutoDetectorOptions);
+    /**
+     * Detect backend availability and recommend best option.
+     *
+     * The detection logic follows this priority:
+     * 1. If preferPowerSync is true and PowerSync is available, use PowerSync
+     * 2. If PowerSync is initializing and online with Supabase available, use Supabase temporarily
+     * 3. If online with Supabase available, use Supabase
+     * 4. If offline but PowerSync available, use PowerSync (offline mode)
+     * 5. Default to Supabase as fallback
+     *
+     * @returns Detection result with recommendation and reasoning
+     */
+    detect(): AutoDetectionResult;
+    /**
+     * Check if PowerSync is available.
+     *
+     * PowerSync is considered available if we have a database instance.
+     * The actual sync status would be checked via PowerSync's status API
+     * when the full SDK is integrated.
+     *
+     * @returns PowerSync backend status
+     */
+    detectPowerSyncStatus(): BackendStatus;
+    /**
+     * Check if Supabase is available.
+     *
+     * Supabase is considered available if we have a client instance.
+     * The actual network connectivity is checked separately via checkOnlineStatus().
+     *
+     * @returns Supabase backend status
+     */
+    detectSupabaseStatus(): BackendStatus;
+    /**
+     * Check if device is online.
+     *
+     * Uses navigator.onLine in browser environments.
+     * Returns true by default for non-browser environments (React Native
+     * would need NetInfo integration via dependency injection).
+     *
+     * @returns Whether the device has network connectivity
+     */
+    checkOnlineStatus(): boolean;
+    /**
+     * Update PowerSync instance (e.g., when it becomes available).
+     *
+     * @param db - New PowerSync database instance or null
+     */
+    setPowerSync(db: PowerSyncDatabase | null): void;
+    /**
+     * Update Supabase instance.
+     *
+     * @param supabase - New Supabase client instance or null
+     */
+    setSupabase(supabase: SupabaseClient | null): void;
+    /**
+     * Get current PowerSync instance.
+     *
+     * @returns Current PowerSync database instance or null
+     */
+    getPowerSync(): PowerSyncDatabase | null;
+    /**
+     * Get current Supabase instance.
+     *
+     * @returns Current Supabase client instance or null
+     */
+    getSupabase(): SupabaseClient | null;
+    /**
+     * Update detector options.
+     *
+     * @param options - New options to merge with existing
+     */
+    setOptions(options: Partial<AutoDetectorOptions>): void;
+    /**
+     * Get current detector options.
+     *
+     * @returns Current detector options
+     */
+    getOptions(): Required<AutoDetectorOptions>;
+    /**
+     * Add a listener for backend change events.
+     *
+     * @param listener - Callback to invoke when detection result changes
+     * @returns Function to remove the listener
+     */
+    addListener(listener: BackendChangeListener): () => void;
+    /**
+     * Remove a listener for backend change events.
+     *
+     * @param listener - Listener to remove
+     */
+    removeListener(listener: BackendChangeListener): void;
+    /**
+     * Get the last detection result.
+     *
+     * @returns Last detection result or null if never detected
+     */
+    getLastResult(): AutoDetectionResult | null;
+    /**
+     * Check if the detection result has changed from the last result.
+     */
+    private hasResultChanged;
+    /**
+     * Notify all listeners of a detection result change.
+     */
+    private notifyListeners;
+}
+/**
+ * Create an AdapterAutoDetector instance.
+ *
+ * @param powerSyncDb - PowerSync database instance or null
+ * @param supabase - Supabase client instance or null
+ * @param options - Detection options
+ * @returns New AdapterAutoDetector instance
+ *
+ * @example
+ * ```typescript
+ * const detector = createAdapterAutoDetector(powerSyncDb, supabaseClient, {
+ *   preferPowerSync: true,
+ *   statusCheckTimeout: 2000,
+ * });
+ *
+ * const { recommendedBackend, reason } = detector.detect();
+ * ```
+ */
+declare function createAdapterAutoDetector(powerSyncDb: PowerSyncDatabase | null, supabase: SupabaseClient | null, options?: AutoDetectorOptions): AdapterAutoDetector;
+
+/**
+ * V3 Data Layer Adapter Registry
+ *
+ * Factory that creates and manages adapter instances based on table configuration.
+ * Uses lazy initialization to create adapters on first access.
+ */
+
+/**
+ * Registry that manages and provides adapters based on table configuration.
+ *
+ * The registry:
+ * - Stores configuration for table strategies
+ * - Lazily creates adapters when first accessed
+ * - Caches created adapters for reuse
+ * - Provides default fallback for unconfigured tables
+ *
+ * Usage:
+ * ```typescript
+ * const registry = createAdapterRegistry(config);
+ *
+ * // Later, when providers initialize:
+ * registry.setPowerSyncAdapter(powerSyncAdapter);
+ * registry.setSupabaseAdapter(supabaseAdapter);
+ *
+ * // Get adapter for a table:
+ * const adapter = registry.getAdapter("Project");
+ * ```
+ */
+declare class AdapterRegistry {
+    private config;
+    /**
+     * Cache of created adapters by table name
+     */
+    private adapters;
+    /**
+     * PowerSync adapter instance (set during initialization)
+     */
+    private powerSyncAdapter;
+    /**
+     * Supabase adapter instance (set during initialization)
+     */
+    private supabaseAdapter;
+    /**
+     * Cached adapter instance (wraps Supabase with TanStack Query)
+     */
+    private cachedAdapter;
+    /**
+     * Dependencies for creating adapters
+     */
+    private deps;
+    /**
+     * Whether the registry has been initialized with adapters
+     */
+    private _isInitialized;
+    /**
+     * Auto-detector instance for automatic backend selection
+     */
+    private autoDetector;
+    /**
+     * Listeners for backend change events
+     */
+    private backendChangeListeners;
+    /**
+     * Last auto-detection result for debugging and status
+     */
+    private lastDetectionResult;
+    /**
+     * Create a new adapter registry
+     *
+     * @param config - Data layer configuration with table strategies
+     */
+    constructor(config: DataLayerConfig);
+    /**
+     * Check if the registry has been initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Initialize the registry with dependencies.
+     * Called by DataLayerProvider when PowerSync and Supabase are ready.
+     *
+     * @param deps - Dependencies needed to create adapters
+     */
+    initialize(deps: AdapterDependencies): void;
+    /**
+     * Set the PowerSync adapter instance
+     *
+     * @param adapter - PowerSync adapter implementation
+     */
+    setPowerSyncAdapter(adapter: TableDataAdapter): void;
+    /**
+     * Set the Supabase adapter instance
+     *
+     * @param adapter - Supabase adapter implementation
+     */
+    setSupabaseAdapter(adapter: TableDataAdapter): void;
+    /**
+     * Set the Cached adapter instance
+     *
+     * @param adapter - Cached adapter implementation
+     */
+    setCachedAdapter(adapter: TableDataAdapter): void;
+    /**
+     * Initialize auto-detection with a detector instance
+     *
+     * @param detector - The auto-detector to use
+     */
+    initializeAutoDetection(detector: AdapterAutoDetector): void;
+    /**
+     * Get the appropriate adapter for a table based on configuration.
+     *
+     * The adapter is selected based on the table's strategy in config.tables:
+     * - "powersync": Returns PowerSyncAdapter
+     * - "supabase": Returns SupabaseAdapter
+     * - "cached": Returns CachedAdapter (wrapping Supabase)
+     * - "hybrid": Returns HybridAdapter (combining PowerSync + Cached)
+     * - "auto": Uses auto-detection to select the best backend
+     *
+     * For tables not in config, defaults to auto-detection if available,
+     * otherwise falls back to SupabaseAdapter.
+     *
+     * @param table - The table name
+     * @returns The appropriate adapter for the table
+     * @throws Error if adapters are not initialized
+     */
+    getAdapter(table: string): TableDataAdapter;
+    /**
+     * Get the PowerSync adapter directly
+     *
+     * @returns PowerSync adapter or null if not initialized
+     */
+    getPowerSyncAdapter(): TableDataAdapter | null;
+    /**
+     * Get the Supabase adapter directly
+     *
+     * @returns Supabase adapter or null if not initialized
+     */
+    getSupabaseAdapter(): TableDataAdapter | null;
+    /**
+     * Get the Cached adapter directly
+     *
+     * @returns Cached adapter or null if not initialized
+     */
+    getCachedAdapter(): TableDataAdapter | null;
+    /**
+     * Get all configured table names
+     *
+     * @returns Array of table names with explicit strategy configuration
+     */
+    getConfiguredTables(): string[];
+    /**
+     * Get the strategy for a specific table
+     *
+     * @param table - The table name
+     * @returns The table strategy or undefined if not configured
+     */
+    getTableStrategy(table: string): TableStrategy | undefined;
+    /**
+     * Check if a table uses PowerSync strategy
+     *
+     * @param table - The table name
+     * @returns True if table uses PowerSync or Hybrid strategy
+     */
+    usesPowerSync(table: string): boolean;
+    /**
+     * Get all tables that use PowerSync
+     *
+     * @returns Array of table names using PowerSync or Hybrid strategy
+     */
+    getPowerSyncTables(): string[];
+    /**
+     * Get adapter using auto-detection
+     *
+     * @param strategy - Optional auto strategy configuration
+     * @returns The automatically selected adapter
+     */
+    private getAutoAdapter;
+    /**
+     * Subscribe to backend changes
+     *
+     * @param callback - Function called when recommended backend changes
+     * @returns Unsubscribe function
+     */
+    onBackendChange(callback: (backend: "powersync" | "supabase") => void): () => void;
+    /**
+     * Notify listeners of backend change
+     *
+     * @param backend - The new recommended backend
+     */
+    private notifyBackendChange;
+    /**
+     * Get the last auto-detection result
+     *
+     * @returns Last detection result or null if never detected
+     */
+    getLastDetectionResult(): AutoDetectionResult | null;
+    /**
+     * Get the auto-detector instance
+     *
+     * @returns Auto-detector instance or null if not initialized
+     */
+    getAutoDetector(): AdapterAutoDetector | null;
+    /**
+     * Create an adapter based on the strategy type
+     *
+     * @param strategy - The table strategy configuration
+     * @returns The created adapter
+     * @throws Error if the required base adapter is not initialized
+     */
+    private createAdapter;
+    /**
+     * Clear all cached adapters.
+     * Useful when configuration changes and adapters need to be recreated.
+     */
+    clearCache(): void;
+    /**
+     * Reset the registry to uninitialized state.
+     * Used during cleanup or testing.
+     */
+    reset(): void;
+    /**
+     * Dispose all adapters and clean up resources.
+     * Called when the DataLayerProvider unmounts.
+     */
+    dispose(): void;
+    /**
+     * Get debug information about the registry state
+     */
+    getDebugInfo(): {
+        isInitialized: boolean;
+        hasPowerSync: boolean;
+        hasSupabase: boolean;
+        hasCached: boolean;
+        cachedAdapterCount: number;
+        configuredTableCount: number;
+        powerSyncTables: string[];
+        hasAutoDetector: boolean;
+        lastDetectionResult: AutoDetectionResult | null;
+    };
+}
+/**
+ * Create a new adapter registry
+ *
+ * @param config - Data layer configuration
+ * @returns A new AdapterRegistry instance
+ *
+ * @example
+ * ```typescript
+ * const config: DataLayerConfig = {
+ *   schema: databaseSchema,
+ *   connections: { ... },
+ *   tables: {
+ *     Project: { strategy: "powersync", syncScope: "activeProject" },
+ *     AuditLog: { strategy: "supabase" },
+ *     Report: { strategy: "cached", cacheTime: 60000 },
+ *   },
+ *   scopes: { ... },
+ *   defaults: { syncMode: "live" },
+ * };
+ *
+ * const registry = createAdapterRegistry(config);
+ *
+ * // In provider:
+ * registry.setPowerSyncAdapter(new PowerSyncAdapter(db, schema));
+ * registry.setSupabaseAdapter(new SupabaseAdapter(supabase));
+ *
+ * // In hooks:
+ * const adapter = registry.getAdapter("Project"); // Returns PowerSyncAdapter
+ * ```
+ */
+declare function createAdapterRegistry(config: DataLayerConfig): AdapterRegistry;
+
+/**
+ * Status of the data layer initialization
+ */
+interface DataLayerStatus {
+    /** Whether the data layer is fully initialized */
+    isInitialized: boolean;
+    /** Current active backend */
+    currentBackend: "powersync" | "supabase" | null;
+    /** PowerSync connection status */
+    powerSyncStatus: BackendStatus;
+    /** Whether device is online */
+    isOnline: boolean;
+    /** Last auto-detection result */
+    lastDetection: AutoDetectionResult | null;
+    /** Initialization error if any */
+    error: Error | null;
+}
+/**
+ * Context value for the data layer
+ */
+interface DataLayerContextValue {
+    /** Adapter registry for getting table adapters */
+    registry: AdapterRegistry;
+    /** Get adapter for a specific table */
+    getAdapter: (table: string) => TableDataAdapter;
+    /** PowerSync database instance (null when not available) */
+    powerSync: PowerSyncDatabase | null;
+    /** Supabase client (always available) */
+    supabase: SupabaseClient;
+    /** React Query client */
+    queryClient: QueryClient;
+    /** Database schema */
+    schema: DatabaseSchema;
+    /** Current status */
+    status: DataLayerStatus;
+    /** Sync status (for PowerSync, no-op for Supabase-only) */
+    syncStatus: SyncStatus;
+    /** Sync controls (for PowerSync, no-op for Supabase-only) */
+    syncControl: SyncControl;
+}
+/**
+ * Data layer context
+ *
+ * Provides access to the V3 data layer throughout the React component tree.
+ * Must be accessed via the useDataLayer hook or similar consumer.
+ */
+declare const DataLayerContext: react.Context<DataLayerContextValue>;
+
+/**
+ * V3 Data Layer Hook
+ *
+ * Provides access to the V3 data layer context for components.
+ * This hook is the primary entry point for accessing adapters,
+ * status information, and core data layer functionality.
+ */
+
+/**
+ * Hook to access the V3 data layer context
+ *
+ * Provides access to:
+ * - registry: Adapter registry for getting table adapters
+ * - getAdapter: Function to get adapter for a specific table
+ * - powerSync: PowerSync database instance (null when not available)
+ * - supabase: Supabase client (always available)
+ * - queryClient: React Query client
+ * - schema: Database schema
+ * - status: Current initialization and connection status
+ * - syncStatus: Sync status for PowerSync
+ * - syncControl: Sync controls for PowerSync
+ *
+ * @throws Error if used outside of DataLayerProvider
+ *
+ * @example
+ * const { getAdapter, status } = useDataLayer();
+ *
+ * if (status.isInitialized) {
+ *   const adapter = getAdapter("Task");
+ *   // Use adapter...
+ * }
+ */
+declare function useDataLayer(): DataLayerContextValue;
+/**
+ * Hook to safely access data layer context (returns null if not in provider)
+ *
+ * Use this when you need to check if the data layer is available
+ * without throwing an error. Useful for conditional rendering or
+ * components that may be rendered outside the provider context.
+ *
+ * @example
+ * const dataLayer = useDataLayerOptional();
+ *
+ * if (dataLayer) {
+ *   // Safe to use data layer
+ * } else {
+ *   // Render fallback UI
+ * }
+ */
+declare function useDataLayerOptional(): DataLayerContextValue | null;
+
+/**
+ * V3 useDbQuery Hook
+ *
+ * React hook for querying multiple records from a table.
+ * Works identically whether PowerSync or Supabase is the backend.
+ * Uses React Query for state management and caching.
+ *
+ * Types are automatically inferred from table names when you augment
+ * the DatabaseTypes interface with your app's Database type.
+ *
+ * @example
+ * // In your app's types/db.d.ts:
+ * declare module "@pol-studios/db" {
+ *   interface DatabaseTypes {
+ *     database: import("@/database.types").Database;
+ *   }
+ * }
+ *
+ * // Then usage auto-infers types:
+ * const { data } = useDbQuery("EquipmentFixtureUnit", { ... });
+ * // data is typed as Tables<"EquipmentFixtureUnit">[]
+ */
+
+/**
+ * Augment this interface in your app to enable automatic type inference.
+ *
+ * @example
+ * // In types/db.d.ts
+ * declare module "@pol-studios/db" {
+ *   interface DatabaseTypes {
+ *     database: import("@/database.types").Database;
+ *   }
+ * }
+ */
+interface DatabaseTypes$1 {
+}
+/**
+ * The configured Database type, or a generic fallback
+ */
+type ConfiguredDatabase$1 = DatabaseTypes$1 extends {
+    database: infer DB;
+} ? DB : GenericSchema$1;
+/**
+ * Generic schema structure for fallback
+ */
+type GenericSchema$1 = {
+    public: {
+        Tables: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+        Views: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+    };
+    [schema: string]: {
+        Tables: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+        Views?: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+    };
+};
+/**
+ * Default schema from Database (usually "public")
+ */
+type DefaultSchema$1 = ConfiguredDatabase$1 extends {
+    public: infer S;
+} ? S : never;
+/**
+ * Extract all valid table names from the default schema
+ */
+type PublicTableNames$1 = DefaultSchema$1 extends {
+    Tables: infer T;
+} ? keyof T & string : string;
+/**
+ * Extract all valid schema names
+ */
+type SchemaNames$1 = keyof ConfiguredDatabase$1 & string;
+/**
+ * Extract table names for a specific schema
+ */
+type SchemaTableNames$1<S extends string> = ConfiguredDatabase$1 extends {
+    [K in S]: {
+        Tables: infer T;
+    };
+} ? keyof T & string : string;
+/**
+ * Build dot notation strings for all schema.table combinations
+ */
+type SchemaDotTable$1 = {
+    [S in SchemaNames$1]: S extends "public" ? never : `${S}.${SchemaTableNames$1<S>}`;
+}[SchemaNames$1];
+/**
+ * Table identifier - provides autocomplete for valid table names
+ *
+ * Supports:
+ * - "TableName" - public schema tables
+ * - "schema.TableName" - dot notation for other schemas
+ * - { schema, table } - object format for other schemas
+ */
+type TableIdentifier$1 = PublicTableNames$1 | SchemaDotTable$1 | {
+    [S in Exclude<SchemaNames$1, "public">]: {
+        schema: S;
+        table: SchemaTableNames$1<S>;
+    };
+}[Exclude<SchemaNames$1, "public">];
+/**
+ * Resolve row type from a table identifier
+ *
+ * Supports:
+ * - "TableName" → public schema
+ * - "schema.TableName" → specified schema (dot notation)
+ * - { schema: "schema", table: "TableName" } → specified schema (object)
+ */
+type ResolveRowType$1<T extends TableIdentifier$1> = T extends string ? T extends `${infer Schema}.${infer Table}` ? ConfiguredDatabase$1 extends {
+    [K in Schema]: {
+        Tables: {
+            [K2 in Table]: {
+                Row: infer R;
+            };
+        };
+    };
+} ? R : Record<string, unknown> : DefaultSchema$1 extends {
+    Tables: {
+        [K in T]: {
+            Row: infer R;
+        };
+    };
+} ? R : DefaultSchema$1 extends {
+    Views: {
+        [K in T]: {
+            Row: infer R;
+        };
+    };
+} ? R : Record<string, unknown> : T extends {
+    schema: infer S;
+    table: infer TN;
+} ? S extends string ? TN extends string ? ConfiguredDatabase$1 extends {
+    [K in S]: {
+        Tables: {
+            [K2 in TN]: {
+                Row: infer R;
+            };
+        };
+    };
+} ? R : Record<string, unknown> : Record<string, unknown> : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Options for useDbQuery hook
+ */
+interface UseDbQueryOptions extends Omit<QueryOptions, "enabled"> {
+    /** Whether the query is enabled (default: true) */
+    enabled?: boolean;
+    /**
+     * React Query stale time in ms
+     * Default depends on backend:
+     * - PowerSync (offline): 0 - always refetch from SQLite (disk is fast)
+     * - Supabase (online): 30000 - use normal caching
+     */
+    staleTime?: number;
+    /** React Query gcTime (cache time) in ms (default: 300000 - 5 minutes) */
+    gcTime?: number;
+    /** Whether to refetch on window focus (default: true) */
+    refetchOnWindowFocus?: boolean;
+    /**
+     * Whether to refetch on mount
+     * Default depends on backend:
+     * - PowerSync (offline): "always" - always query SQLite
+     * - Supabase (online): true - refetch if stale
+     */
+    refetchOnMount?: boolean | "always";
+    /** Whether to enable real-time subscriptions (if adapter supports) */
+    realtime?: boolean;
+    /** If true, returns single item instead of array (for compatibility with V2) */
+    single?: boolean;
+}
+/**
+ * Result from useDbQuery hook
+ */
+interface UseDbQueryResult<T> {
+    /** Query data */
+    data: T[] | undefined;
+    /** Whether query is loading (initial load) */
+    isLoading: boolean;
+    /** Whether query is in pending state */
+    isPending: boolean;
+    /** Whether query is currently fetching (including refetch) */
+    isFetching: boolean;
+    /** Whether query is currently refetching (alias for isFetching for V2 compatibility) */
+    isRefetching: boolean;
+    /** Whether query completed successfully */
+    isSuccess: boolean;
+    /** Whether query errored */
+    isError: boolean;
+    /** Query error if any */
+    error: Error | null;
+    /** Refetch the query */
+    refetch: () => Promise<void>;
+    /** Total count (if pagination is used) */
+    count?: number;
+    /** Whether data is stale */
+    isStale: boolean;
+    /** Timestamp of last data update */
+    dataUpdatedAt: number | null;
+}
+/**
+ * Hook for querying multiple records from a table
+ *
+ * This hook provides a unified interface for querying data that works
+ * identically whether the backend is PowerSync (offline-first) or
+ * Supabase (online-only). It uses React Query for caching and state management.
+ *
+ * Features:
+ * - Automatic type inference from table names (when DatabaseTypes is augmented)
+ * - Automatic backend selection based on DataLayerProvider configuration
+ * - React Query integration for caching, deduplication, and background updates
+ * - Optional real-time subscriptions (when adapter supports it)
+ * - Pagination support with count
+ *
+ * @param table - Table name (string) or { schema, table } object
+ * @param options - Query options (select, where, orderBy, limit, offset, etc.)
+ * @returns Query result with data, loading states, error, and refetch function
+ *
+ * @example
+ * // Basic query - types auto-inferred from table name
+ * const { data } = useDbQuery("EquipmentFixtureUnit");
+ * // data is typed as Tables<"EquipmentFixtureUnit">[]
+ *
+ * @example
+ * // Query from non-public schema
+ * const { data } = useDbQuery({ schema: "core", table: "Profile" });
+ * // data is typed as Tables<{ schema: "core" }, "Profile">[]
+ *
+ * @example
+ * // Query with filters and sorting
+ * const { data } = useDbQuery("Task", {
+ *   select: "*, Project(*)",
+ *   where: { status: "active" },
+ *   orderBy: [{ field: "createdAt", direction: "desc" }],
+ *   limit: 10,
+ * });
+ */
+/**
+ * Main hook signature with auto-inferred types from table identifiers
+ */
+declare function useDbQuery<T extends TableIdentifier$1>(table: T, options?: UseDbQueryOptions): UseDbQueryResult<ResolveRowType$1<T>>;
+/**
+ * Overload for explicit type parameter when table name is a string literal
+ */
+declare function useDbQuery<T>(table: string, options?: UseDbQueryOptions): UseDbQueryResult<T>;
+
+/**
+ * V3 useDbQueryById Hook
+ *
+ * React hook for querying a single record by ID from a table.
+ * Works identically whether PowerSync or Supabase is the backend.
+ * Uses React Query for state management and caching.
+ */
+/**
+ * Options for useDbQueryById hook
+ */
+interface UseDbQueryByIdOptions {
+    /** Columns to select (Supabase-style select string) */
+    select?: string;
+    /** Whether the query is enabled (default: true if id is provided) */
+    enabled?: boolean;
+    /** React Query stale time in ms (default: 30000) */
+    staleTime?: number;
+}
+/**
+ * Result from useDbQueryById hook
+ */
+interface UseDbQueryByIdResult<T> {
+    /** Query data (undefined while loading, null if not found) */
+    data: T | null | undefined;
+    /** Whether query is loading (initial load) */
+    isLoading: boolean;
+    /** Whether query is in pending state */
+    isPending: boolean;
+    /** Whether query is currently fetching (including refetch) */
+    isFetching: boolean;
+    /** Query error if any */
+    error: Error | null;
+    /** Refetch the query */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for querying a single record by ID
+ *
+ * This hook provides a unified interface for fetching a single record that works
+ * identically whether the backend is PowerSync (offline-first) or
+ * Supabase (online-only). It uses React Query for caching and state management.
+ *
+ * Features:
+ * - Automatic backend selection based on DataLayerProvider configuration
+ * - React Query integration for caching, deduplication, and background updates
+ * - Automatic disabling when ID is null/undefined
+ * - Fallback to query with where clause if adapter doesn't support queryById
+ * - Type-safe with generic type parameter
+ *
+ * @param table - The table name to query
+ * @param id - The record ID (query is disabled if null/undefined)
+ * @param options - Query options (select, enabled, staleTime)
+ * @returns Query result with data, loading states, error, and refetch function
+ *
+ * @example
+ * // Basic query by ID
+ * const { data, isLoading, error } = useDbQueryById<Task>("Task", taskId);
+ *
+ * @example
+ * // Query with relations
+ * const { data, isLoading, error } = useDbQueryById<Task>("Task", taskId, {
+ *   select: "*, Project(*), AssignedUser:User(*)",
+ * });
+ *
+ * @example
+ * // Conditional query based on other state
+ * const { data } = useDbQueryById<Project>("Project", selectedProjectId, {
+ *   enabled: hasPermission && !!selectedProjectId,
+ * });
+ *
+ * @example
+ * // With custom stale time
+ * const { data } = useDbQueryById<User>("User", userId, {
+ *   staleTime: 60000, // 1 minute
+ * });
+ */
+declare function useDbQueryById<T = Record<string, unknown>>(table: string, id: string | number | null | undefined, options?: UseDbQueryByIdOptions): UseDbQueryByIdResult<T>;
+
+/**
+ * V3 useAdvanceQuery Hook
+ *
+ * Hybrid query hook that combines PowerSync (local SQLite) with edge function filtering.
+ * - When NO filters active: Uses PowerSync for fast local queries that stay in sync
+ * - When filters active: Uses edge function for complex filtering
+ *
+ * This provides the best of both worlds:
+ * - Fast, reactive local queries via PowerSync
+ * - Complex filtering, natural language queries, and aggregations via edge function
+ *
+ * @example
+ * const [result, filters, setFilters] = useAdvanceQuery<Equipment[]>(
+ *   "EquipmentFixtureUnit",
+ *   {
+ *     select: "*, EquipmentFixtureUnitControl(*)",
+ *     where: { projectDatabaseId: 123 },
+ *     orderBy: [{ field: "unitNumber", direction: "asc" }],
+ *     filterKey: "equipment-filters",
+ *   }
+ * );
+ */
+
+type FilterOperator = "=" | ">" | ">=" | "<" | "<=" | "contains" | "ilike" | "is" | "in" | "ai_search";
+interface Filter {
+    id: string;
+    field: string;
+    op: FilterOperator;
+    value: string | number | string[] | number[] | boolean | null;
+    not?: boolean;
+    similarity?: number;
+    where?: string;
+    display?: string;
+}
+interface FilterGroup {
+    id: string;
+    op: "AND" | "OR";
+    filters: Array<Filter | FilterGroup>;
+    not?: boolean;
+}
+interface Pagination {
+    offset?: number;
+    limit?: number;
+}
+interface Sort {
+    field: string;
+    direction: "asc" | "desc";
+}
+interface QueryState extends FilterGroup {
+    pagination?: Pagination;
+    sort?: Sort[];
+    distinctOn?: string[];
+    naturalLanguageQuery?: string;
+    isReady: boolean;
+}
+interface ClarificationQuestion {
+    question: string;
+    suggestions: Array<{
+        interpretation: string;
+        field_path: string;
+        example: string;
+        confidence: number;
+    }>;
+}
+interface UseAdvanceQueryOptions extends Omit<UseDbQueryOptions, "realtime"> {
+    /** Key for persisting filter state (required for filter state persistence) */
+    filterKey: string;
+    /** Initial filter state */
+    initialFilters?: QueryState;
+    /** Timeout for edge function requests in ms (default: 15000) */
+    timeout?: number;
+    /** Count mode: "exact" | "estimated" | "" (default: "exact") */
+    count?: "exact" | "estimated" | "";
+    /**
+     * Whether to enable real-time subscriptions
+     * - PowerSync path: Uses watch() for reactive updates (default: true when PowerSync)
+     * - Edge function path: Uses Supabase realtime to invalidate query on changes
+     */
+    realtime?: boolean;
+}
+interface UseAdvanceQueryResult<T> {
+    data: T[] | undefined;
+    isLoading: boolean;
+    isPending: boolean;
+    isFetching: boolean;
+    isRefetching: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    count?: number;
+    clarification?: ClarificationQuestion;
+}
+/**
+ * Hybrid advance query hook
+ *
+ * Uses PowerSync (local SQLite) when no filters are active for fast, reactive queries.
+ * Falls back to edge function when filters are active for complex filtering.
+ */
+declare function useAdvanceQuery<T extends TableIdentifier$1>(table: T, options: UseAdvanceQueryOptions): [
+    UseAdvanceQueryResult<ResolveRowType$1<T>>,
+    QueryState,
+    Dispatch<SetStateAction<QueryState>>
+];
+declare function useAdvanceQuery<T>(table: string, options: UseAdvanceQueryOptions): [
+    UseAdvanceQueryResult<T>,
+    QueryState,
+    Dispatch<SetStateAction<QueryState>>
+];
+
+/**
+ * V3 useDbInsert Hook
+ *
+ * React hook for inserting records into a table using the V3 adapter pattern.
+ * Integrates with React Query for mutation management and cache invalidation.
+ */
+/**
+ * Options for useDbInsert hook
+ */
+interface UseDbInsertOptions<T> {
+    /** Callback when insert succeeds */
+    onSuccess?: (data: T) => void;
+    /** Callback when insert fails */
+    onError?: (error: Error) => void;
+    /** Tables to invalidate after successful insert */
+    invalidateTables?: string[];
+}
+/**
+ * Result from useDbInsert hook
+ */
+interface UseDbInsertResult<T> {
+    /** Trigger insert (fire and forget) */
+    mutate: (data: Partial<T>) => void;
+    /** Trigger insert and await result */
+    mutateAsync: (data: Partial<T>) => Promise<T>;
+    /** Whether mutation is in progress */
+    isPending: boolean;
+    /** Mutation error if any */
+    error: Error | null;
+    /** Reset mutation state */
+    reset: () => void;
+    /** Last successful data */
+    data: T | undefined;
+}
+/**
+ * Hook for inserting records into a table
+ *
+ * Uses the V3 adapter pattern to route inserts to the appropriate backend
+ * (PowerSync, Supabase, or Cached) based on table configuration.
+ *
+ * @param table - The table name to insert into
+ * @param options - Optional configuration for callbacks and cache invalidation
+ * @returns Mutation result with mutate/mutateAsync functions
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync, isPending } = useDbInsert<Task>("Task");
+ * const newTask = await mutateAsync({ title: "New Task", status: "pending" });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With options
+ * const { mutate } = useDbInsert<Project>("Project", {
+ *   onSuccess: (data) => console.log("Created:", data),
+ *   onError: (error) => console.error("Failed:", error),
+ *   invalidateTables: ["Project", "ProjectSummary"],
+ * });
+ * ```
+ */
+declare function useDbInsert<T = Record<string, unknown>>(table: string, options?: UseDbInsertOptions<T>): UseDbInsertResult<T>;
+
+/**
+ * V3 useDbUpdate Hook
+ *
+ * React hook for updating records in a table using the V3 adapter pattern.
+ * Integrates with React Query for mutation management, cache invalidation,
+ * and optional optimistic updates.
+ */
+/**
+ * Options for useDbUpdate hook
+ */
+interface UseDbUpdateOptions<T> {
+    /** Callback when update succeeds */
+    onSuccess?: (data: T) => void;
+    /** Callback when update fails */
+    onError?: (error: Error) => void;
+    /** Tables to invalidate after successful update */
+    invalidateTables?: string[];
+    /** Enable optimistic updates */
+    optimistic?: boolean;
+}
+/**
+ * Result from useDbUpdate hook
+ */
+interface UseDbUpdateResult<T> {
+    /** Trigger update (fire and forget) */
+    mutate: (params: {
+        id: string;
+        data: Partial<T>;
+    }) => void;
+    /** Trigger update and await result */
+    mutateAsync: (params: {
+        id: string;
+        data: Partial<T>;
+    }) => Promise<T>;
+    /** Whether mutation is in progress */
+    isPending: boolean;
+    /** Mutation error if any */
+    error: Error | null;
+    /** Reset mutation state */
+    reset: () => void;
+    /** Last successful data */
+    data: T | undefined;
+}
+/**
+ * Hook for updating records in a table
+ *
+ * Uses the V3 adapter pattern to route updates to the appropriate backend
+ * (PowerSync, Supabase, or Cached) based on table configuration.
+ *
+ * @param table - The table name to update records in
+ * @param options - Optional configuration for callbacks, cache invalidation, and optimistic updates
+ * @returns Mutation result with mutate/mutateAsync functions
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync, isPending } = useDbUpdate<Task>("Task");
+ * const updated = await mutateAsync({ id: taskId, data: { status: "completed" } });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With optimistic updates
+ * const { mutate } = useDbUpdate<Project>("Project", {
+ *   optimistic: true,
+ *   onSuccess: (data) => console.log("Updated:", data),
+ *   onError: (error) => console.error("Failed:", error),
+ * });
+ * ```
+ */
+declare function useDbUpdate<T = Record<string, unknown>>(table: string, options?: UseDbUpdateOptions<T>): UseDbUpdateResult<T>;
+
+/**
+ * V3 useDbUpsert Hook
+ *
+ * React hook for upserting (insert or update) records in a table using the V3 adapter pattern.
+ * Integrates with React Query for mutation management and cache invalidation.
+ */
+/**
+ * Options for useDbUpsert hook
+ */
+interface UseDbUpsertOptions<T> {
+    /** Callback when upsert succeeds */
+    onSuccess?: (data: T) => void;
+    /** Callback when upsert fails */
+    onError?: (error: Error) => void;
+    /** Tables to invalidate after successful upsert */
+    invalidateTables?: string[];
+}
+/**
+ * Result from useDbUpsert hook
+ */
+interface UseDbUpsertResult<T> {
+    /** Trigger upsert (fire and forget) */
+    mutate: (data: Partial<T>) => void;
+    /** Trigger upsert and await result */
+    mutateAsync: (data: Partial<T>) => Promise<T>;
+    /** Whether mutation is in progress */
+    isPending: boolean;
+    /** Mutation error if any */
+    error: Error | null;
+    /** Reset mutation state */
+    reset: () => void;
+    /** Last successful data */
+    data: T | undefined;
+}
+/**
+ * Hook for upserting (insert or update) records in a table
+ *
+ * Uses the V3 adapter pattern to route upserts to the appropriate backend
+ * (PowerSync, Supabase, or Cached) based on table configuration.
+ *
+ * If the record has an ID and exists, it will be updated.
+ * Otherwise, a new record will be inserted.
+ *
+ * @param table - The table name to upsert into
+ * @param options - Optional configuration for callbacks and cache invalidation
+ * @returns Mutation result with mutate/mutateAsync functions
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync, isPending } = useDbUpsert<Task>("Task");
+ * const task = await mutateAsync({ id: existingId, title: "Updated Title" });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Insert if no ID, update if ID exists
+ * const { mutate } = useDbUpsert<Setting>("Setting", {
+ *   onSuccess: (data) => console.log("Upserted:", data),
+ *   invalidateTables: ["Setting", "UserPreferences"],
+ * });
+ *
+ * // This will insert (no id)
+ * mutate({ key: "theme", value: "dark" });
+ *
+ * // This will update (has id)
+ * mutate({ id: "setting-123", key: "theme", value: "light" });
+ * ```
+ */
+declare function useDbUpsert<T = Record<string, unknown>>(table: string, options?: UseDbUpsertOptions<T>): UseDbUpsertResult<T>;
+
+/**
+ * V3 useDbDelete Hook
+ *
+ * React hook for deleting records from a table using the V3 adapter pattern.
+ * Integrates with React Query for mutation management, cache invalidation,
+ * and optional optimistic deletes.
+ */
+/**
+ * Options for useDbDelete hook
+ */
+interface UseDbDeleteOptions {
+    /** Callback when delete succeeds */
+    onSuccess?: () => void;
+    /** Callback when delete fails */
+    onError?: (error: Error) => void;
+    /** Tables to invalidate after successful delete */
+    invalidateTables?: string[];
+    /** Enable optimistic delete */
+    optimistic?: boolean;
+}
+/**
+ * Result from useDbDelete hook
+ */
+interface UseDbDeleteResult {
+    /** Trigger delete (fire and forget) */
+    mutate: (id: string) => void;
+    /** Trigger delete and await completion */
+    mutateAsync: (id: string) => Promise<void>;
+    /** Whether mutation is in progress */
+    isPending: boolean;
+    /** Mutation error if any */
+    error: Error | null;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Hook for deleting records from a table
+ *
+ * Uses the V3 adapter pattern to route deletes to the appropriate backend
+ * (PowerSync, Supabase, or Cached) based on table configuration.
+ *
+ * @param table - The table name to delete from
+ * @param options - Optional configuration for callbacks, cache invalidation, and optimistic deletes
+ * @returns Mutation result with mutate/mutateAsync functions
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync, isPending } = useDbDelete("Task");
+ * await mutateAsync(taskId);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With optimistic delete for instant UI feedback
+ * const { mutate } = useDbDelete("Comment", {
+ *   optimistic: true,
+ *   onSuccess: () => console.log("Deleted successfully"),
+ *   onError: (error) => console.error("Delete failed:", error),
+ *   invalidateTables: ["Comment", "Post"],
+ * });
+ *
+ * // Immediately removes from UI, rolls back on failure
+ * mutate(commentId);
+ * ```
+ */
+declare function useDbDelete(table: string, options?: UseDbDeleteOptions): UseDbDeleteResult;
+
+/**
+ * V3 useDbInfiniteQuery Hook
+ *
+ * React hook for querying records with infinite scroll pagination.
+ * Works identically whether PowerSync or Supabase is the backend.
+ * Uses React Query's useInfiniteQuery for state management and caching.
+ *
+ * Types are automatically inferred from table names when you augment
+ * the DatabaseTypes interface with your app's Database type.
+ *
+ * @example
+ * // In your app's types/db.d.ts:
+ * declare module "@pol-studios/db" {
+ *   interface DatabaseTypes {
+ *     database: import("@/database.types").Database;
+ *   }
+ * }
+ *
+ * // Then usage auto-infers types:
+ * const { data, fetchNextPage, hasNextPage } = useDbInfiniteQuery("EquipmentFixtureUnit", {
+ *   pageSize: 20,
+ *   orderBy: [{ field: "createdAt", direction: "desc" }],
+ * });
+ */
+
+/**
+ * Augment this interface in your app to enable automatic type inference.
+ */
+interface DatabaseTypes {
+}
+/**
+ * The configured Database type, or a generic fallback
+ */
+type ConfiguredDatabase = DatabaseTypes extends {
+    database: infer DB;
+} ? DB : GenericSchema;
+/**
+ * Generic schema structure for fallback
+ */
+type GenericSchema = {
+    public: {
+        Tables: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+        Views: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+    };
+    [schema: string]: {
+        Tables: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+        Views?: Record<string, {
+            Row: Record<string, unknown>;
+        }>;
+    };
+};
+/**
+ * Default schema from Database (usually "public")
+ */
+type DefaultSchema = ConfiguredDatabase extends {
+    public: infer S;
+} ? S : never;
+/**
+ * Extract all valid table names from the default schema
+ */
+type PublicTableNames = DefaultSchema extends {
+    Tables: infer T;
+} ? keyof T & string : string;
+/**
+ * Extract all valid schema names
+ */
+type SchemaNames = keyof ConfiguredDatabase & string;
+/**
+ * Extract table names for a specific schema
+ */
+type SchemaTableNames<S extends string> = ConfiguredDatabase extends {
+    [K in S]: {
+        Tables: infer T;
+    };
+} ? keyof T & string : string;
+/**
+ * Build dot notation strings for all schema.table combinations
+ */
+type SchemaDotTable = {
+    [S in SchemaNames]: S extends "public" ? never : `${S}.${SchemaTableNames<S>}`;
+}[SchemaNames];
+/**
+ * Table identifier - provides autocomplete for valid table names
+ */
+type TableIdentifier = PublicTableNames | SchemaDotTable | {
+    [S in Exclude<SchemaNames, "public">]: {
+        schema: S;
+        table: SchemaTableNames<S>;
+    };
+}[Exclude<SchemaNames, "public">];
+/**
+ * Resolve row type from a table identifier
+ */
+type ResolveRowType<T extends TableIdentifier> = T extends string ? T extends `${infer Schema}.${infer Table}` ? ConfiguredDatabase extends {
+    [K in Schema]: {
+        Tables: {
+            [K2 in Table]: {
+                Row: infer R;
+            };
+        };
+    };
+} ? R : Record<string, unknown> : DefaultSchema extends {
+    Tables: {
+        [K in T]: {
+            Row: infer R;
+        };
+    };
+} ? R : DefaultSchema extends {
+    Views: {
+        [K in T]: {
+            Row: infer R;
+        };
+    };
+} ? R : Record<string, unknown> : T extends {
+    schema: infer S;
+    table: infer TN;
+} ? S extends string ? TN extends string ? ConfiguredDatabase extends {
+    [K in S]: {
+        Tables: {
+            [K2 in TN]: {
+                Row: infer R;
+            };
+        };
+    };
+} ? R : Record<string, unknown> : Record<string, unknown> : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Options for useDbInfiniteQuery hook
+ */
+interface UseDbInfiniteQueryOptions extends Omit<QueryOptions, "limit" | "offset" | "enabled"> {
+    /** Whether the query is enabled (default: true) */
+    enabled?: boolean;
+    /** React Query stale time in ms (default: 30000) */
+    staleTime?: number;
+    /** Whether to refetch on window focus (default: true) */
+    refetchOnWindowFocus?: boolean;
+    /** Number of items per page (default: 50) */
+    pageSize?: number;
+    /** Text to search for */
+    searchText?: string;
+    /** Fields to search in when searchText is provided */
+    searchFields?: string[];
+}
+/**
+ * Result from useDbInfiniteQuery hook
+ */
+interface UseDbInfiniteQueryResult<T> {
+    /** Flattened array of all loaded data */
+    data: T[] | undefined;
+    /** Whether query is loading (initial load) */
+    isLoading: boolean;
+    /** Whether query is in pending state */
+    isPending: boolean;
+    /** Whether query is currently fetching (including refetch) */
+    isFetching: boolean;
+    /** Query error if any */
+    error: Error | null;
+    /** Function to fetch the next page */
+    fetchNextPage: () => Promise<void>;
+    /** Whether there are more pages to load */
+    hasNextPage: boolean;
+    /** Whether currently fetching the next page */
+    isFetchingNextPage: boolean;
+    /** Total count of items (if available) */
+    count?: number;
+    /** Refetch all pages */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for querying records with infinite scroll pagination
+ *
+ * @param table - Table name (string) or { schema, table } object
+ * @param options - Query options (select, where, orderBy, pageSize, searchText, etc.)
+ * @returns Query result with data, loading states, pagination controls, and refetch function
+ *
+ * @example
+ * // Basic infinite query - types auto-inferred from table name
+ * const { data, fetchNextPage, hasNextPage } = useDbInfiniteQuery("EquipmentFixtureUnit");
+ *
+ * @example
+ * // With search and pagination
+ * const { data, fetchNextPage, hasNextPage, isFetchingNextPage } = useDbInfiniteQuery("Task", {
+ *   pageSize: 20,
+ *   searchText: searchQuery,
+ *   searchFields: ["name", "description"],
+ *   orderBy: [{ field: "createdAt", direction: "desc" }],
+ * });
+ *
+ * @example
+ * // In a FlatList or similar
+ * <FlatList
+ *   data={data}
+ *   onEndReached={() => hasNextPage && fetchNextPage()}
+ *   ListFooterComponent={isFetchingNextPage ? <Spinner /> : null}
+ * />
+ */
+declare function useDbInfiniteQuery<T extends TableIdentifier>(table: T, options?: UseDbInfiniteQueryOptions): UseDbInfiniteQueryResult<ResolveRowType<T>>;
+/**
+ * Overload for explicit type parameter (backwards compatibility)
+ */
+declare function useDbInfiniteQuery<T>(table: string, options?: UseDbInfiniteQueryOptions): UseDbInfiniteQueryResult<T>;
+
+/**
+ * V3 useDbCount Hook
+ *
+ * React hook for counting records in a table.
+ * Works with the data layer using either PowerSync or Supabase backend.
+ */
+
+/**
+ * Options for useDbCount hook
+ */
+interface UseDbCountOptions {
+    /** Filter conditions */
+    where?: WhereClause;
+    /** Whether the query is enabled (default: true) */
+    enabled?: boolean;
+    /** React Query stale time in ms (default: 30000) */
+    staleTime?: number;
+}
+/**
+ * Result from useDbCount hook
+ */
+interface UseDbCountResult {
+    /** The count value */
+    count: number | undefined;
+    /** Whether query is loading */
+    isLoading: boolean;
+    /** Whether query is fetching */
+    isFetching: boolean;
+    /** Query error if any */
+    error: Error | null;
+    /** Refetch the count */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for counting records in a table
+ *
+ * @param table - The table name to count
+ * @param options - Count options (where filter, enabled)
+ * @returns Count result with loading states
+ *
+ * @example
+ * // Simple count
+ * const { count, isLoading } = useDbCount("EquipmentFixtureUnit");
+ *
+ * @example
+ * // Count with filter
+ * const { count } = useDbCount("EquipmentFixtureUnit", {
+ *   where: { projectDatabaseId: 123 },
+ * });
+ */
+declare function useDbCount(table: string, options?: UseDbCountOptions): UseDbCountResult;
+
+export { type UseDbDeleteResult as $, type AdapterQueryResult as A, BackendStatus as B, type CapableDataAdapter as C, type DataLayerContextValue as D, type Pagination as E, type Filter as F, type Sort as G, type ClarificationQuestion as H, type UseAdvanceQueryOptions as I, type UseAdvanceQueryResult as J, useDbInsert as K, type UseDbInsertOptions as L, type UseDbInsertResult as M, useDbUpdate as N, type UseDbUpdateOptions as O, type PublicTableNames$1 as P, type QueryState as Q, type ResolveRowType$1 as R, type SchemaNames$1 as S, type TableDataAdapter as T, type UseDbQueryOptions as U, type UseDbUpdateResult as V, useDbUpsert as W, type UseDbUpsertOptions as X, type UseDbUpsertResult as Y, useDbDelete as Z, type UseDbDeleteOptions as _, type AdapterConfig as a, useDbInfiniteQuery as a0, type UseDbInfiniteQueryOptions as a1, type UseDbInfiniteQueryResult as a2, useDbCount as a3, type UseDbCountOptions as a4, type UseDbCountResult as a5, DataLayerContext as a6, type DataLayerStatus as a7, type AdapterFactory as b, type AdapterCapabilities as c, type AdapterDependencies as d, type AdapterStrategyType as e, ADAPTER_STRATEGIES as f, AdapterRegistry as g, createAdapterRegistry as h, AdapterAutoDetector as i, createAdapterAutoDetector as j, type AutoDetectionResult as k, type AutoDetectorOptions as l, type BackendChangeListener as m, useDataLayerOptional as n, useDbQuery as o, type DatabaseTypes$1 as p, type SchemaTableNames$1 as q, type TableIdentifier$1 as r, type UseDbQueryResult as s, useDbQueryById as t, useDataLayer as u, type UseDbQueryByIdOptions as v, type UseDbQueryByIdResult as w, useAdvanceQuery as x, type FilterGroup as y, type FilterOperator as z };