import * as React from 'react';
import { B as NeetruClient, h as CheckoutStartResult, A as AuthNamespace, U as NeetruUser } from './types-CRIIjqzC.js';
import { CollectionReference, Query, DocumentReference } from './firestore-compat.js';
import 'drizzle-orm/node-postgres';
import './errors.js';

/**
 * SDK React helpers (v1.1) — subpath import `@neetru/sdk/react`.
 *
 * Helpers leves pra React 18+/19. Não puxa `react` como dep direta — caller
 * fornece via peer (alinhado com `@stripe/react-stripe-js` / `firebase`).
 *
 * Exports:
 *   - `<CheckoutLink>` — wrapper de `<a>` que chama `client.checkout.start()` no click.
 *   - `<EntitlementGate>` — wrapper que gateia children por entitlement check
 *     (suporte a `mode='readonly'` pro decisão CEO §5).
 *   - `useEntitlementContext()` — hook pra ler estado de readonly do contexto.
 *
 * **Bundle**: este file SÓ é carregado por quem importa `@neetru/sdk/react`.
 * Tree-shake garante que SDK consumers Node-only (CLI, edge handlers) não
 * puxam React mesmo via transitive.
 */

interface CheckoutLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | 'onClick' | 'onError'> {
    /** Cliente SDK Neetru. Passado explicitamente pra evitar context provider. */
    client: NeetruClient;
    /** Slug do produto (ex: `neetru-pulse`). */
    productId: string;
    /** Plan id (ex: `pro_monthly`). */
    planId: string;
    /** Pra onde o produto SaaS quer voltar pós-checkout. */
    callbackUrl: string;
    /** Override pra checkout em nome de uma org. Default: PF do uid logado. */
    tenantType?: 'pf' | 'pj';
    tenantId?: string;
    /** Children — texto/JSX do CTA. */
    children: React.ReactNode;
    /** Callback quando intent foi criada (antes de redirect). */
    onIntentCreated?: (result: CheckoutStartResult) => void;
    /** Callback de erro. */
    onError?: (err: Error) => void;
    /** Quando true, NÃO redireciona automaticamente — caller controla. */
    noAutoRedirect?: boolean;
    /** Override de href (default: `#`). */
    href?: string;
}
/**
 * Wrapper de `<a>` que dispara `client.checkout.start()` no click.
 *
 * Uso típico:
 * ```tsx
 * <CheckoutLink
 *   client={client}
 *   productId="meu-saas"
 *   planId="pro_monthly"
 *   callbackUrl="https://meu-saas.com/billing/success"
 * >
 *   Assinar Pro
 * </CheckoutLink>
 * ```
 *
 * `href` é stub (`#`) — preventDefault no click. Mantido pra a11y / preview
 * de URL no hover (pode ser sobrescrito via prop spread).
 */
declare function CheckoutLink({ client, productId, planId, callbackUrl, tenantType, tenantId, children, onIntentCreated, onError, noAutoRedirect, ...rest }: CheckoutLinkProps): React.ReactElement;
/** Modo de gate quando entitlement não é permitido. */
type EntitlementGateMode = 'block' | 'readonly';
interface EntitlementContextValue {
    /** True quando feature está em modo read-only (limit exceeded). */
    readonly: boolean;
    /** Reason code da última check. */
    reason?: string;
    /** Limite atual (free tier). */
    limit?: number;
    /** Uso atual. */
    currentUsage?: number;
}
/** Hook pra ler estado de readonly. Componentes filhos consomem isso pra
 * desabilitar inputs/botões de escrita. */
declare function useEntitlementContext(): EntitlementContextValue;
interface EntitlementGateProps {
    /** Cliente SDK Neetru. */
    client: NeetruClient;
    /** Feature key a checar (ex: `export.csv`). */
    feature: string;
    /** Slug do produto. Default: lê do client.config se ausente. */
    productSlug?: string;
    /** Modo:
     *  - `block` (default): renderiza fallback quando não permitido.
     *  - `readonly`: sempre renderiza children mas injeta `readonly: true` no contexto. */
    mode?: EntitlementGateMode;
    /** Fallback UI quando `mode='block'` e check retorna `allowed=false`. */
    fallback?: React.ReactNode;
    /** Loading UI enquanto check resolve (Suspense-like). */
    loading?: React.ReactNode;
    children: React.ReactNode;
}
/**
 * Wrapper que gateia children por entitlement check.
 *
 * Quando `mode='readonly'` + check retorna `behavior='readonly'`:
 *   - Children renderizam normalmente.
 *   - Context injeta `{readonly: true}`.
 *   - Componentes filhos chamam `useEntitlementContext()` pra desabilitar
 *     escritas (botões, forms, inputs).
 *
 * Quando `mode='block'` + check retorna `allowed=false`:
 *   - `fallback` é renderizado (ex: paywall, upsell modal).
 *
 * Decisão CEO §5 (overage): plataforma usa `readonly` sempre — produto SaaS
 * deve preferir `mode='readonly'` pra preservar engajamento (não hard-block).
 */
declare function EntitlementGate({ client, feature, productSlug, mode, fallback, loading, children, }: EntitlementGateProps): React.ReactElement;
/**
 * Resultado de `useCollection` (subpath `@neetru/sdk/react`, API firestore-compat).
 *
 * Nome distinto de `UseCollectionResult` do subpath `@neetru/sdk/db/react`:
 *   - `src/db/react.ts` → `{ docs, loading, fromCache, stale, hasPendingWrites }`
 *   - `src/react.ts`    → `{ data, isLoading, error, isStale, lastUpdated }` (este)
 *
 * Consumers que importam de ambos subpaths não terão clash de tipo.
 * Alias de retrocompat `UseCollectionResult` exportado abaixo.
 */
interface FirestoreCompatCollectionResult<T> {
    /** Documentos (cada um com `id` embutido) ou `null` enquanto carrega/sem ref. */
    data: Array<T & {
        id: string;
    }> | null;
    /** `true` enquanto o primeiro snapshot não chegou. */
    isLoading: boolean;
    /** Erro do último refresh (dados exibidos podem estar defasados). */
    error: Error | null;
    /** `true` quando um refresh falhou ou o snapshot veio do cache/offline. */
    isStale: boolean;
    /** epoch ms do último snapshot bem-sucedido, ou `null`. */
    lastUpdated: number | null;
}
/**
 * Alias de retrocompat — exportado para não quebrar produtos que importam
 * `UseCollectionResult` do subpath `@neetru/sdk/react`. Prefira
 * `FirestoreCompatCollectionResult` em código novo para evitar o clash de nome
 * com `UseCollectionResult` de `@neetru/sdk/db/react`.
 *
 * @deprecated Use `FirestoreCompatCollectionResult` em novo código.
 */
type UseCollectionResult<T> = FirestoreCompatCollectionResult<T>;
/** Resultado de `useDoc`. */
interface UseDocResult<T> {
    data: (T & {
        id: string;
    }) | null;
    isLoading: boolean;
    error: Error | null;
    isStale: boolean;
    lastUpdated: number | null;
}
/** Opções comuns dos hooks de dados. */
interface UseDataOptions {
    /**
     * Intervalo de polling de fallback em ms (quando o transporte não oferece
     * realtime nativo). Default 5000. O polling pausa quando a aba está oculta.
     */
    intervalMs?: number;
    /**
     * Força polling mesmo quando o `onSnapshot` nativo está disponível. Útil para
     * transportes REST onde `onSnapshot` só entrega o snapshot inicial.
     * Default: `false` (usa realtime quando o transporte oferece).
     */
    poll?: boolean;
}
/**
 * Hook de tempo real para uma coleção (ou subconjunto filtrado via `query`).
 *
 * Aceita uma `CollectionReference` ou `Query` do `@neetru/sdk/firestore-compat`.
 * Subscreve ao `onSnapshot` nativo do `client.db`; quando o transporte é REST
 * (sem realtime nativo), faz polling visibility-aware no `intervalMs`.
 *
 * ```tsx
 * import { collection, query, where } from '@neetru/sdk/firestore-compat';
 * import { useCollection } from '@neetru/sdk/react';
 *
 * const ref = useMemo(
 *   () => query(collection(client.db, 'orders'), where('status', '==', 'open')),
 *   [],
 * );
 * const { data, isLoading, error, isStale } = useCollection<Order>(ref);
 * ```
 *
 * Seguro em React 18/19 StrictMode.
 */
declare function useCollection<T = Record<string, unknown>>(source: CollectionReference<T> | Query<T> | null | undefined, options?: UseDataOptions): UseCollectionResult<T>;
/**
 * Hook de tempo real para um documento.
 *
 * Aceita uma `DocumentReference` do `@neetru/sdk/firestore-compat`.
 *
 * ```tsx
 * import { doc } from '@neetru/sdk/firestore-compat';
 * import { useDoc } from '@neetru/sdk/react';
 *
 * const ref = useMemo(() => doc(client.db, 'profiles', uid), [uid]);
 * const { data, isLoading } = useDoc<Profile>(ref);
 * ```
 *
 * Seguro em React 18/19 StrictMode.
 */
declare function useDoc<T = Record<string, unknown>>(ref: DocumentReference<T> | null | undefined, options?: UseDataOptions): UseDocResult<T>;
/**
 * Fonte de auth aceita por `useUser`: o `NeetruClient` inteiro (resolve
 * `client.auth`) ou o `AuthNamespace` direto.
 */
type UseUserInput = NeetruClient | {
    auth: AuthNamespace;
} | AuthNamespace;
/** Resultado de `useUser`. */
interface UseUserResult {
    /** Usuário autenticado ou `null`. */
    user: NeetruUser | null;
    /** `true` enquanto o estado de auth inicial não foi resolvido. */
    isLoading: boolean;
    /** Erro na resolução de auth (raro — listener nunca deveria lançar). */
    error: Error | null;
}
/**
 * Hook de estado de autenticação.
 *
 * Subscreve a `client.auth.onAuthStateChanged` e devolve `{ user, isLoading,
 * error }`. Inclui um **timeout de seed** (default 8s): se o estado de auth não
 * resolver nesse prazo, `isLoading` cai para `false` com `user: null` — evita
 * spinners infinitos quando o provedor de auth nunca dispara o callback.
 *
 * ```tsx
 * import { useUser } from '@neetru/sdk/react';
 * const { user, isLoading } = useUser(client);
 * if (isLoading) return <Spinner />;
 * if (!user) return <SignInButton />;
 * return <Avatar user={user} />;
 * ```
 *
 * Aceita o `NeetruClient`, `{ auth }` ou o `AuthNamespace` direto.
 * Seguro em React 18/19 StrictMode.
 */
declare function useUser(input: UseUserInput, options?: {
    timeoutMs?: number;
}): UseUserResult;

export { CheckoutLink, type CheckoutLinkProps, EntitlementGate, type EntitlementGateMode, type EntitlementGateProps, type FirestoreCompatCollectionResult, type UseCollectionResult, type UseDataOptions, type UseDocResult, type UseUserInput, type UseUserResult, useCollection, useDoc, useEntitlementContext, useUser };
