import { ac as SyncState, ah as Unsubscribe, p as DbDoc, B as NeetruClient, o as DbCollectionRef, u as DbQuery } from './types-CRIIjqzC.js';
import 'drizzle-orm/node-postgres';
import './errors.js';

/**
 * Resultado de `useDocument`.
 *
 * - `data` — dados do documento, ou `null` se não existe / ainda carregando.
 * - `loading` — `true` enquanto o primeiro snapshot não foi entregue.
 * - `fromCache` — o snapshot veio do cache local, não do servidor.
 * - `stale` — conexão caída ou sincronizando; pode haver dados mais novos.
 */
interface UseDocumentResult<T> {
    data: T | null;
    loading: boolean;
    fromCache: boolean;
    stale: boolean;
}
/**
 * Resultado de `useCollection`.
 *
 * - `docs` — documentos da coleção (ou subconjunto via query).
 * - `loading` — `true` enquanto o primeiro snapshot não foi entregue.
 * - `fromCache` — o snapshot veio do cache local.
 * - `stale` — conexão caída ou sincronizando.
 * - `hasPendingWrites` — ao menos um doc tem escrita local não confirmada.
 */
interface UseCollectionResult<T> {
    docs: DbDoc<T>[];
    loading: boolean;
    fromCache: boolean;
    stale: boolean;
    hasPendingWrites: boolean;
}
/**
 * Subconjunto mínimo do namespace offline que `useSyncState` precisa.
 * Compatível com `NeetruDbDocuments` de `collection-ref.ts`.
 *
 * Passado explicitamente (sem Context) para alinhar com o padrão do SDK.
 * Tipicamente: o namespace retornado por `createOfflineDocumentsNamespace`.
 *
 * `client.db` (o `NeetruDb` retornado por `createNeetruClient`) também satisfaz
 * este contrato — expõe `syncState` + `onSyncStateChanged` reais. Por isso
 * `useSyncState` aceita tanto a fonte direta quanto o `NeetruClient` inteiro
 * (ver `UseSyncStateInput`).
 */
interface SyncStateSource {
    readonly syncState: SyncState;
    onSyncStateChanged(cb: (s: SyncState) => void): Unsubscribe;
}
/**
 * Entrada aceita por `useSyncState`:
 *   - `NeetruClient`     → resolve `client.db` automaticamente (forma oficial,
 *                          alinhada com 02-sdk.md §3.6 `useSyncState(client)`).
 *   - `SyncStateSource`  → fonte direta (`client.db` ou o namespace offline cru).
 */
type UseSyncStateInput = NeetruClient | SyncStateSource;
/**
 * Hook de tempo real para um documento específico.
 *
 * Subscreve a `ref.doc(id).onSnapshot` no mount. Re-subscreve quando `ref`
 * ou `id` mudam. Cancela a subscrição no unmount.
 *
 * ```tsx
 * const { data, loading, fromCache, stale } = useDocument(ordersRef, orderId);
 * if (loading) return <Spinner />;
 * if (!data) return <NotFound />;
 * return <OrderCard order={data} fromCache={fromCache} />;
 * ```
 *
 * Seguro em React 18/19 StrictMode: a cleanup function do useEffect cancela
 * o listener no unmount, e o double-mount do StrictMode não vaza estado.
 */
declare function useDocument<T>(ref: DbCollectionRef<T>, id: string): UseDocumentResult<T>;
/**
 * Hook de tempo real para uma coleção (ou subconjunto filtrado).
 *
 * Subscreve a `ref.onSnapshot(query, cb)` no mount. Re-subscreve quando `ref`
 * ou a serialização de `query` muda — NÃO por identidade de objeto, o que
 * evita re-subscribe desnecessário em inline objects.
 *
 * ```tsx
 * const { docs, loading, hasPendingWrites } = useCollection(ordersRef, {
 *   where: [{ field: 'status', op: '==', value: 'open' }],
 * });
 * ```
 *
 * Seguro em React 18/19 StrictMode.
 */
declare function useCollection<T>(ref: DbCollectionRef<T>, query?: DbQuery): UseCollectionResult<T>;
/**
 * Hook para observar o `SyncState` da camada offline em tempo real.
 *
 * Retorna o `SyncState` atual e re-renderiza quando ele muda. Usado para
 * renderizar indicadores "sincronizando…" / "offline" / contadores de escritas
 * pendentes na UI.
 *
 * Aceita duas formas de entrada (SDK-QW-4 — wiring ao client real):
 *
 * ```tsx
 * // Forma oficial — passe o client; o hook resolve client.db internamente.
 * const client = createNeetruClient({ apiKey });
 * const state = useSyncState(client);
 *
 * // Forma direta — passe a fonte (client.db ou o namespace offline cru).
 * const state = useSyncState(client.db);
 *
 * if (state.status === 'offline') return <OfflineBanner pending={state.pendingWrites} />;
 * ```
 *
 * Antes desta versão o hook só aceitava a `SyncStateSource` crua, o que levava
 * consumers a stub-arem o estado pra sempre `'idle'` em vez de ligar no client.
 * Agora `useSyncState(client)` (a forma documentada em 02-sdk.md §3.6) funciona
 * de ponta a ponta — `client.db.syncState` / `client.db.onSyncStateChanged` são
 * reais.
 *
 * Seguro em React 18/19 StrictMode.
 */
declare function useSyncState(input: UseSyncStateInput): SyncState;

export { type SyncStateSource, type UseCollectionResult, type UseDocumentResult, type UseSyncStateInput, useCollection, useDocument, useSyncState };
