import { Q as QueryOperator, b as QueryResult, M as MutationOperator } from '../../ApprovalOperator-Cc5TpPnT.js';
export { K as ApprovalFilters, L as CreateApprovalInput, B as CreateDiscussionInput, H as CreateDocumentInput, q as CreateMilestoneInput, g as CreateOrgInput, m as CreateProjectInput, C as CreateTaskInput, y as CreateTemplateInput, u as CreateUserInput, j as CreateWorkspaceInput, A as DiscussionFilters, G as DocumentFilters, p as MilestoneFilters, c as MutationOptions, d as MutationState, f as OrgFilters, l as ProjectFilters, a as QueryOptions, e as TaskFilters, x as TemplateFilters, N as UpdateApprovalInput, E as UpdateDiscussionInput, I as UpdateDocumentInput, r as UpdateMilestoneInput, h as UpdateOrgInput, n as UpdateProjectInput, U as UpdateTaskInput, z as UpdateTemplateInput, v as UpdateUserInput, k as UpdateWorkspaceInput, t as UserFilters, i as WorkspaceFilters } from '../../ApprovalOperator-Cc5TpPnT.js';
import * as react_jsx_runtime from 'react/jsx-runtime';
import React from 'react';
import { QueryClient } from '@tanstack/react-query';
import { C as CollectionModeConfig, D as D1Client, a as CollectionMode } from '../../d1Client-BfyBzH2u.js';
import 'rxdb';
import '../../Workspace-CoUdcswi.js';
import '../../types-5lxby8F5.js';
import 'rxjs';

/**
 * React hook for framework-agnostic QueryOperator
 *
 * Subscribes to a QueryOperator's observable and manages state with React hooks.
 * Handles null operators gracefully and cleans up subscriptions on unmount.
 *
 * @param queryOperator - QueryOperator instance or null
 * @returns QueryResult with data, isLoading, and error
 *
 * @example
 * ```tsx
 * function TaskList() {
 *   const db = useDatabase();
 *   const queryOperator = useMemo(() => {
 *     if (!db) return null;
 *     const taskOps = new TaskOperator(db);
 *     return taskOps.query({ orgId: 'org_123', status: 'in_progress' });
 *   }, [db]);
 *
 *   const result = useQuery(queryOperator);
 *
 *   if (result.isLoading) return <div>Loading...</div>;
 *   if (result.error) return <div>Error: {result.error.message}</div>;
 *
 *   return (
 *     <ul>
 *       {result.data.map(task => (
 *         <li key={task.id}>{task.title}</li>
 *       ))}
 *     </ul>
 *   );
 * }
 * ```
 */
declare function useQuery<T>(queryOperator: QueryOperator<T> | null): QueryResult<T>;

/**
 * React hook for querying a collection by name.
 *
 * Routes to local RxDB or remote D1 based on CollectionModeProvider context.
 * When no provider is mounted, all collections route to local.
 *
 * @param db - RxDatabase instance (or null/undefined)
 * @param collectionName - Name of the collection to query
 * @param queryBuilder - Optional function that receives the RxCollection and returns an RxQuery.
 *   Only used in local mode. In remote mode, all documents are fetched.
 * @returns Object with `data`, `isLoading`, and `error`
 *
 * @example
 * ```tsx
 * function ProjectSelect({ orgId }: { orgId: string }) {
 *   const { db } = useDatabase();
 *   const queryBuilder = useCallback(
 *     (collection: RxCollection) =>
 *       collection.find({ selector: { orgId, archived: false } }),
 *     [orgId]
 *   );
 *   const { data, isLoading } = useCollectionQuery(db, 'projects', queryBuilder);
 *
 *   if (isLoading) return <div>Loading...</div>;
 *   return (
 *     <select>
 *       {data.map(p => <option key={p.id} value={p.id}>{p.title}</option>)}
 *     </select>
 *   );
 * }
 * ```
 */
declare function useCollectionQuery<T = Record<string, unknown>>(db: any, collectionName: string, queryBuilder?: (collection: any) => any): {
    data: T[];
    isLoading: boolean;
    error: Error | null;
};

/**
 * Return type for useMutation hook
 */
interface UseMutationResult<TData, TVariables> {
    /** Execute mutation with variables */
    mutate: (variables: TVariables) => void;
    /** Execute mutation with variables and return Promise */
    mutateAsync: (variables: TVariables) => Promise<TData>;
    /** True while mutation is executing */
    isLoading: boolean;
    /** Error object if mutation failed */
    error: Error | null;
    /** Result data from successful mutation */
    data: TData | null;
    /** Reset mutation state to initial values */
    reset: () => void;
}
/**
 * React hook for framework-agnostic MutationOperator
 *
 * Subscribes to a MutationOperator's state and provides mutation functions.
 * Handles null operators gracefully and cleans up subscriptions on unmount.
 *
 * @param mutationOperator - MutationOperator instance or null
 * @returns UseMutationResult with mutate functions and state
 *
 * @example
 * ```tsx
 * function CreateTaskForm() {
 *   const db = useDatabase();
 *   const mutationOperator = useMemo(() => {
 *     if (!db) return null;
 *     const taskOps = new TaskOperator(db);
 *     return taskOps.createMutation();
 *   }, [db]);
 *
 *   const { mutate, isLoading, error, data } = useMutation(mutationOperator);
 *
 *   const handleSubmit = (e) => {
 *     e.preventDefault();
 *     mutate({
 *       title: 'New Task',
 *       description: 'Task description',
 *       orgId: 'org_123',
 *       userId: 'user_456',
 *       projectId: 'proj_789',
 *       milestoneId: 'mile_101'
 *     });
 *   };
 *
 *   if (isLoading) return <div>Creating task...</div>;
 *   if (error) return <div>Error: {error.message}</div>;
 *   if (data) return <div>Task created: {data.id}</div>;
 *
 *   return <form onSubmit={handleSubmit}>...</form>;
 * }
 * ```
 */
declare function useMutation<TData, TVariables>(mutationOperator: MutationOperator<TData, TVariables> | null): UseMutationResult<TData, TVariables>;

/**
 * Query options accepted by Operator.query() methods.
 */
interface CollectionQueryOptions {
    sort?: string;
    limit?: number;
    skip?: number;
}
/**
 * Minimum interface any Operator class passed to createCollectionHooks must satisfy.
 */
interface CollectionOperatorInterface<TModel, TFilters, TCreate, TUpdate> {
    query(filters: TFilters, options?: CollectionQueryOptions): QueryOperator<TModel>;
    createMutation(): MutationOperator<TModel, TCreate>;
    updateMutation(): MutationOperator<TModel, TUpdate>;
    deleteMutation(): MutationOperator<void, string>;
}
/**
 * Constructor type for classes implementing CollectionOperatorInterface.
 */
type CollectionOperatorClass<TModel, TFilters, TCreate, TUpdate> = new (db: any) => CollectionOperatorInterface<TModel, TFilters, TCreate, TUpdate>;
/**
 * The four hooks returned by createCollectionHooks.
 */
interface CollectionHooks<TModel, TFilters, TCreate, TUpdate> {
    /**
     * Query hook. Returns { data, isLoading, error }.
     * Returns empty/not-loading when db or filters is null/undefined.
     */
    useItems: (db: any, filters: TFilters, options?: CollectionQueryOptions) => QueryResult<TModel>;
    /** Create mutation hook. Returns UseMutationResult. */
    useCreate: (db: any) => UseMutationResult<TModel, TCreate>;
    /** Update mutation hook. Returns UseMutationResult. */
    useUpdate: (db: any) => UseMutationResult<TModel, TUpdate>;
    /** Soft-delete mutation hook. Returns UseMutationResult<void, string>. */
    useDelete: (db: any) => UseMutationResult<void, string>;
}
/**
 * Factory that creates React hooks for a collection operator class.
 *
 * Replaces per-entity boilerplate hook files (useProjects.ts, useMilestones.ts,
 * etc.) by generating a typed hook set from any operator class that satisfies
 * CollectionOperatorInterface.
 *
 * The returned hooks accept `db` as their first argument (Layer 1 pattern).
 * App-level code wraps them calling useDatabase() internally (Layer 2 pattern).
 *
 * @param OperatorClass - Any operator class constructor (e.g., ProjectOperator)
 * @returns { useItems, useCreate, useUpdate, useDelete }
 *
 * @example
 * ```ts
 * import { createCollectionHooks, MilestoneOperator } from '@epicdm/flowstate-collections/react'
 * import { useDatabase, useOrgWorkspace } from '@epicdm/flowstate-app-framework'
 *
 * const { useItems, useCreate, useUpdate, useDelete } = createCollectionHooks(MilestoneOperator)
 *
 * export function useProjectMilestones(projectId: string) {
 *   const { db } = useDatabase()
 *   const { currentOrgId } = useOrgWorkspace()
 *   return useItems(db, { orgId: currentOrgId, projectId, archived: false })
 * }
 *
 * export function useCreateMilestone() {
 *   const { db } = useDatabase()
 *   return useCreate(db)
 * }
 * ```
 */
declare function createCollectionHooks<TModel, TFilters, TCreate, TUpdate>(OperatorClass: CollectionOperatorClass<TModel, TFilters, TCreate, TUpdate>): CollectionHooks<TModel, TFilters, TCreate, TUpdate>;

interface UseLocalRecordsOptions {
    selector?: Record<string, unknown>;
    sort?: Array<Record<string, string>>;
    limit?: number;
    skip?: number;
    orgId?: string;
    workspaceId?: string;
}
interface UseLocalRecordsResult<T = Record<string, unknown>> {
    data: T[];
    isLoading: boolean;
    error: Error | null;
    create: (doc: Partial<T>) => Promise<T>;
    update: (id: string, updates: Partial<T>) => Promise<T | null>;
    remove: (id: string) => Promise<boolean>;
    refresh: () => void;
}

type UseRecordsOptions = UseLocalRecordsOptions;
type UseRecordsResult<T = Record<string, unknown>> = UseLocalRecordsResult<T>;
/**
 * Generic React hook for querying and mutating virtual collections.
 *
 * Routes to local RxDB or remote D1 based on CollectionModeProvider context.
 * When no provider is mounted, all collections route to local.
 *
 * @param db - RxDB database instance (must have `schemas` and `records` collections)
 * @param schemaName - Name of the virtual collection schema (e.g. 'products', 'codebases')
 * @param options - Query options: selector, sort, limit, skip, orgId
 * @returns Reactive data array, loading/error state, and CRUD mutations
 */
declare function useRecords<T = Record<string, unknown>>(db: Record<string, any> | null | undefined, schemaName: string, options?: UseRecordsOptions): UseRecordsResult<T>;

interface UseLocalAnyCollectionOptions {
    /** MongoDB-style selector for filtering */
    selector?: Record<string, unknown>;
    /** Sort criteria array, e.g. [{ title: 'asc' }] */
    sort?: Array<Record<string, 'asc' | 'desc'>>;
    /** Maximum number of results */
    limit?: number;
    /** Number of results to skip */
    skip?: number;
    /** Organization ID (needed for virtual collection schema loading) */
    orgId?: string;
}
interface UseLocalAnyCollectionResult<T> {
    data: T[];
    isLoading: boolean;
    error: Error | null;
}
/**
 * Minimal structural type covering the subset of RxDatabase used by this hook.
 * Accepts both native (db.collections) and virtual (db.schemas + db.records) shapes.
 */
interface AnyDb {
    /** Native RxDB collections keyed by name */
    collections?: Record<string, NativeCollection>;
    /** Schema collection for virtual collection support */
    schemas?: unknown;
    /** Records collection for virtual collection support */
    records?: unknown;
}
/** Minimal RxDB document type for native collection results */
interface RxDoc {
    toJSON(): Record<string, unknown>;
}
/** Minimal native RxDB collection interface used by this hook */
interface NativeCollection {
    find(q: {
        selector: Record<string, unknown>;
        sort?: Array<Record<string, 'asc' | 'desc'>>;
    }): NativeQuery;
}
interface NativeQuery {
    skip(n: number): NativeQuery;
    limit(n: number): NativeQuery;
    $: {
        subscribe(observer: {
            next: (docs: RxDoc[]) => void;
            error: (err: Error) => void;
        }): {
            unsubscribe: () => void;
        };
    };
}

type UseAnyCollectionOptions = UseLocalAnyCollectionOptions;
type UseAnyCollectionResult<T> = UseLocalAnyCollectionResult<T>;
/**
 * React hook that queries either a native RxDB collection or a virtual
 * schema-in-db collection transparently.
 *
 * Routes to local RxDB or remote D1 based on CollectionModeProvider context.
 * When no provider is mounted, all collections route to local.
 *
 * @param db - RxDatabase instance (or null/undefined)
 * @param collectionName - Collection name (native or virtual)
 * @param options - Query options: selector, sort, limit, skip, orgId
 * @returns Reactive data array with loading/error state
 */
declare function useAnyCollection<T = Record<string, unknown>>(db: AnyDb | null | undefined, collectionName: string, options?: UseAnyCollectionOptions): UseAnyCollectionResult<T>;

interface CollectionModeContextValue {
    config: CollectionModeConfig;
    queryClient: QueryClient;
    client: D1Client;
    getMode: (collectionName: string) => CollectionMode;
}
interface CollectionModeProviderProps {
    config: CollectionModeConfig;
    queryClient: QueryClient;
    children: React.ReactNode;
}
declare function CollectionModeProvider({ config, queryClient, children, }: CollectionModeProviderProps): react_jsx_runtime.JSX.Element;
/**
 * Access the collection mode context.
 *
 * Returns `null` when the provider is not mounted — consumers should
 * treat null as "all collections are local" for backward compatibility.
 */
declare function useCollectionMode(): CollectionModeContextValue | null;

interface UseRemoteMutationResult<T> {
    create: (doc: Partial<T>) => Promise<T>;
    update: (id: string, updates: Partial<T>) => Promise<T>;
    remove: (id: string) => Promise<boolean>;
    isLoading: boolean;
    error: Error | null;
}
declare function useRemoteMutation<T extends {
    id: string;
}>(collectionName: string): UseRemoteMutationResult<T>;
/**
 * Conditional variant safe to use without a CollectionModeProvider.
 *
 * Uses useState/useCallback directly (no tanstack hooks) so it maintains
 * a consistent hook count regardless of whether a provider is mounted.
 * When `collectionName` is null or no provider exists, returns no-op
 * functions that resolve immediately.
 */
declare function useRemoteMutationConditional<T extends {
    id: string;
}>(collectionName: string | null): UseRemoteMutationResult<T>;

interface UseRemoteQueryOptions {
    selector?: Record<string, unknown>;
    sort?: Array<Record<string, 'asc' | 'desc'>>;
    limit?: number;
    skip?: number;
    staleTime?: number;
    refetchInterval?: number | false;
    enabled?: boolean;
}
interface UseRemoteQueryResult<T> {
    data: T[];
    isLoading: boolean;
    error: Error | null;
}
declare function useRemoteQuery<T = Record<string, unknown>>(collectionName: string, options?: UseRemoteQueryOptions): UseRemoteQueryResult<T>;
/**
 * Conditional variant safe to use without a CollectionModeProvider.
 *
 * Uses useState/useEffect directly (no tanstack hooks) so it maintains
 * a consistent hook count regardless of whether a provider is mounted.
 * When the provider IS mounted, uses QueryClient imperatively for caching.
 * When `collectionName` is null or no provider exists, returns empty data.
 */
declare function useRemoteQueryConditional<T = Record<string, unknown>>(collectionName: string | null, options?: UseRemoteQueryOptions): UseRemoteQueryResult<T>;

export { type CollectionHooks, type CollectionModeContextValue, CollectionModeProvider, type CollectionModeProviderProps, type CollectionOperatorClass, type CollectionOperatorInterface, type CollectionQueryOptions, QueryResult, type UseAnyCollectionOptions, type UseAnyCollectionResult, type UseMutationResult, type UseRecordsOptions, type UseRecordsResult, type UseRemoteMutationResult, type UseRemoteQueryOptions, type UseRemoteQueryResult, createCollectionHooks, useAnyCollection, useCollectionMode, useCollectionQuery, useMutation, useQuery, useRecords, useRemoteMutation, useRemoteMutationConditional, useRemoteQuery, useRemoteQueryConditional };