@pol-studios/db 1.0.19 → 1.0.22

package/dist/useDbCount-s-aR9YeV.d.ts

@@ -0,0 +1,1082 @@
+import { p as DataLayerContextValue, q as DataLayerCoreContextValue, r as DataLayerStatusContextValue } from './DataLayerContext-ZmLPYR_s.js';
+import { Dispatch, SetStateAction } from 'react';
+import { QueryOptions, WhereClause } from './core/index.js';
+
+/**
+ * V3 Data Layer Hooks
+ *
+ * Provides access to the V3 data layer context for components.
+ * This module provides three hooks for different use cases:
+ *
+ * - useDataLayerCore(): Stable values only (registry, adapters, clients)
+ *   Use in query/mutation hooks to avoid re-renders on status changes.
+ *
+ * - useDataLayerStatus(): Dynamic values only (status, syncStatus, syncControl)
+ *   Use for UI components that display sync status, online indicator, etc.
+ *
+ * - useDataLayer(): Combined access (backward compatible)
+ *   Use when you need both core and status values.
+ */
+
+/**
+ * Hook to access ONLY the stable core values (registry, adapters, clients)
+ *
+ * PERFORMANCE BENEFIT: Components using this hook will NOT re-render when
+ * network status or sync status changes. Use this in query/mutation hooks.
+ *
+ * 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
+ *
+ * @throws Error if used outside of DataLayerProvider
+ *
+ * @example
+ * const { getAdapter, supabase } = useDataLayerCore();
+ * const adapter = getAdapter("Task");
+ * // This component won't re-render on sync status changes
+ */
+declare function useDataLayerCore(): DataLayerCoreContextValue;
+/**
+ * Hook to access ONLY the dynamic status values
+ *
+ * PERFORMANCE BENEFIT: Only components that actually need status information
+ * will re-render when status changes. Use for UI components that display
+ * sync status, online indicator, pending uploads count, etc.
+ *
+ * Provides access to:
+ * - 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 { status, syncStatus } = useDataLayerStatus();
+ *
+ * return (
+ *   <StatusBar
+ *     isOnline={status.isOnline}
+ *     pendingUploads={syncStatus.pendingUploads}
+ *   />
+ * );
+ */
+declare function useDataLayerStatus(): DataLayerStatusContextValue;
+/**
+ * Hook to access the V3 data layer context (combined core + status)
+ *
+ * NOTE: Consider using useDataLayerCore() or useDataLayerStatus() instead
+ * for better render performance. This hook re-renders on ALL status changes.
+ *
+ * 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 Sort as A, type UseDbInsertOptions as B, type ClarificationQuestion as C, type DatabaseTypes$1 as D, type UseDbInsertResult as E, type Filter as F, type UseDbUpdateOptions as G, type UseDbUpdateResult as H, type UseDbUpsertOptions as I, type UseDbUpsertResult as J, type UseDbDeleteOptions as K, type UseDbDeleteResult as L, type PublicTableNames$1 as P, type QueryState as Q, type ResolveRowType$1 as R, type SchemaNames$1 as S, type TableIdentifier$1 as T, type UseAdvanceQueryOptions as U, useDataLayer as a, useDataLayerCore as b, useDataLayerStatus as c, useDbCount as d, useDbDelete as e, useDbInfiniteQuery as f, useDbInsert as g, useDbQuery as h, useDbQueryById as i, useDbUpdate as j, useDbUpsert as k, type SchemaTableNames$1 as l, type UseAdvanceQueryResult as m, type UseDbCountOptions as n, type UseDbCountResult as o, type UseDbInfiniteQueryOptions as p, type UseDbInfiniteQueryResult as q, type UseDbQueryOptions as r, type UseDbQueryResult as s, useDataLayerOptional as t, useAdvanceQuery as u, type UseDbQueryByIdOptions as v, type UseDbQueryByIdResult as w, type FilterGroup as x, type FilterOperator as y, type Pagination as z };