import { U as NeetruUser, A as AuthNamespace, a6 as SignInOptions, a as AuthStateListener, a1 as RedirectCallbackResult, H as NeetruDb, o as DbCollectionRef, T as NeetruSqlClient, ac as SyncState, ah as Unsubscribe, j as ConflictRecord, E as EntitlementCheck, a8 as SupportNamespace, l as CreateTicketInput, ab as SupportTicket, aj as UsageNamespace, ak as UsageQuota } from './types-CRIIjqzC.js';
import 'drizzle-orm/node-postgres';
import './errors.js';

/**
 * Mocks determinísticos do SDK — overridáveis em tests do consumer ou
 * ativados automaticamente quando `NEETRU_ENV=dev`.
 *
 * Nada aqui faz I/O. Tudo é puro/sincrono/in-memory. Compat total com
 * runtimes browser/Node/Edge — sem `node:` builtins.
 *
 * Cada mock implementa o mesmo namespace interface das implementações reais
 * (`AuthNamespace`, `UsageNamespace`, `SupportNamespace`) — caller pode
 * substituir 1:1 sem branching.
 *
 * @example
 * ```ts
 * import { createNeetruClient, MockAuth } from '@neetru/sdk';
 *
 * const client = createNeetruClient({
 *   mocks: { auth: new MockAuth({ uid: 'fake-user', email: 'x@x.com' }) },
 * });
 * ```
 */

/**
 * User fixture determinístico — usado quando `NEETRU_ENV=dev` e nenhum mock
 * custom é injetado. Email/uid estáveis pra snapshot tests.
 */
declare const DEV_FIXTURE_USER: NeetruUser;
/**
 * Implementação in-memory do `AuthNamespace`. signIn marca o user como
 * logado; signOut limpa. onAuthStateChanged dispara callback síncrono no
 * subscribe + a cada mudança.
 */
declare class MockAuth implements AuthNamespace {
    private _user;
    private _listeners;
    constructor(initialUser?: NeetruUser | null);
    signIn(_options?: SignInOptions): Promise<NeetruUser>;
    signOut(): Promise<void>;
    getUser(): NeetruUser | null;
    onAuthStateChanged(listener: AuthStateListener): () => void;
    /**
     * Mock de `verifyToken` — decodifica o JWT sem verificar assinatura (pra testes).
     * Em dev, retorna o user atual do mock se já estiver logado. Aceita qualquer token
     * não-vazio sem chamar rede.
     *
     * Para simular falhas em testes, use `MockAuth.__mockVerifyToken(fn)`.
     */
    verifyToken(token: string): Promise<NeetruUser>;
    /**
     * Mock de `handleRedirectCallback` (Bug 2 / 3.1.3) — não há redirect real no
     * mock, então retorna `null` por default. Use `__setPendingCallback(result)`
     * em testes pra simular um retorno do IdP.
     */
    handleRedirectCallback(_currentUrl?: string): Promise<RedirectCallbackResult | null>;
    /**
     * Mock de `getIdToken` (Bug 2 / 3.1.3). Retorna `null` por default; use
     * `__setIdToken(token)` pra injetar um token cru em testes.
     */
    getIdToken(): string | null;
    private _pendingCallback;
    private _idToken;
    /** Test helper — simula o material devolvido por um callback OIDC. */
    __setPendingCallback(result: RedirectCallbackResult | null): void;
    /** Test helper — injeta o id_token cru retornado por `getIdToken`. */
    __setIdToken(token: string | null): void;
    private _verifyTokenOverride;
    /**
     * Injeta override pra `verifyToken` em testes — permite simular expiração,
     * assinatura inválida etc sem precisar de JWT real.
     *
     * @example
     * ```ts
     * const mock = new MockAuth(null);
     * mock.__mockVerifyToken(async () => { throw new NeetruError('token_expired', '...'); });
     * ```
     */
    __mockVerifyToken(fn: ((token: string) => Promise<NeetruUser>) | null): void;
    /** Helper de tests — força um user state arbitrário. */
    __setUser(user: NeetruUser | null): void;
    private _notify;
}
interface UsageReportRecord {
    resource: string;
    qty: number;
    productId?: string;
    tenantId?: string;
    timestamp: string;
}
/**
 * In-memory `UsageNamespace` 3.0. `report()` acumula counter local; `check()`
 * compara com `__setQuota(resource, {used, limit})` fixture.
 *
 * Breaking 3.0:
 *   - `track(event, props)` REMOVIDO.
 *   - `getQuota(metric)` REMOVIDO.
 *   - `__getRecords()` agora retorna `UsageReportRecord[]` (resource/qty).
 */
declare class MockUsage implements UsageNamespace {
    private _reports;
    private _quotas;
    private _counters;
    constructor(initialQuotas?: Record<string, UsageQuota>);
    report(resource: string, qty?: number, options?: {
        productId?: string;
        tenantId?: string;
    }): Promise<{
        ok: true;
        counterId?: string;
        value?: number;
        limit?: number;
        remaining?: number;
        status?: string;
    }>;
    check(resource: string, _options?: {
        productId?: string;
        tenantId?: string;
    }): Promise<{
        allowed: boolean;
        reason?: string;
        remaining?: number;
        limit?: number;
        planId?: string | null;
        planFeatures?: string[];
        behavior?: 'readonly' | null;
    }>;
    /** Test helper — retorna histórico de `report()` calls. */
    __getReports(): readonly UsageReportRecord[];
    /** @deprecated Removido em 3.0 (usage.track foi removido). Use `__getReports`. */
    __getRecords(): readonly UsageReportRecord[];
    /** Test helper — substitui quota fixture. */
    __setQuota(metric: string, quota: UsageQuota): void;
    /** Test helper — limpa estado. */
    __reset(): void;
}
/**
 * In-memory `SupportNamespace`. createTicket gera ID `mock-ticket-{n}`;
 * listMyTickets retorna todos criados (FIFO). Sequência por instância
 * (evita poluição cross-test do estado de módulo).
 */
declare class MockSupport implements SupportNamespace {
    private _tickets;
    private _ticketSeq;
    createTicket(input: CreateTicketInput): Promise<SupportTicket>;
    listMyTickets(options?: {
        productSlug?: string;
    }): Promise<SupportTicket[]>;
    /** Test helper. */
    __reset(): void;
}
/**
 * In-memory entitlements. Por default `allowed=true` em tudo (dev convém).
 * Use `__deny(slug, feature)` em tests pra simular bloqueio.
 */
declare class MockEntitlements {
    private _denied;
    check(productSlug: string, feature: string): Promise<boolean>;
    checkDetailed(productSlug: string, feature: string): Promise<EntitlementCheck>;
    /** Test helper. */
    __deny(productSlug: string, feature: string): void;
    /** Test helper. */
    __reset(): void;
}
/**
 * In-memory `NeetruDb`. Cada `collection(name)` aponta para um Map; ops
 * são totalmente síncronas (mas API await-friendly).
 *
 * v2.0: implementa a interface `NeetruDb` completa (collection, sql, syncState,
 * flush, clearCache, getConflicts, onSyncStateChanged).
 *
 * Útil para testar produtos consumidores sem rodar Core REST nem IndexedDB.
 */
declare class MockDb implements NeetruDb {
    private _store;
    private _fixtures;
    constructor(initialFixtures?: Record<string, Record<string, Record<string, unknown>>>);
    collection<T = Record<string, unknown>>(name: string): DbCollectionRef<T>;
    /**
     * Implementa SQL in-memory para testes — preferência: `@electric-sql/pglite`
     * + `drizzle-orm/pglite`; fallback: `pg-mem` + `drizzle-orm/node-postgres`
     * com strip interceptor.
     *
     * bug_6bae8674461f4600809e2f9de13c6043 (HIGH 26/05): fix anterior (2.3.3)
     * teve efeito INVERSO. Injetar `pool.types.getTypeParser` fez drizzle-orm
     * passar `query.types.getTypeParser` pro pg-mem, que tem guard interno
     * `if (query.types?.getTypeParser) throw NotSupported`. Ou seja: presença
     * de getTypeParser é o gatilho do erro — não ausência.
     *
     * Solução A (pglite, preferida): `@electric-sql/pglite` é WASM-Postgres
     * nativo — sem adapter pg-mem, sem esse conflito de tipos.
     * Solução B (fallback pg-mem): strip interceptor no pool.query que deleta
     * `types.getTypeParser` do objeto de query ANTES do pg-mem ver. Compat com
     * consumers que só têm pg-mem nas devDeps.
     *
     * Use `options.initSql` pra rodar DDL no setup (CREATE TABLE etc).
     */
    sql<TSchema extends Record<string, unknown>>(schema: TSchema, options?: {
        database?: string;
        initSql?: string | string[];
    }): Promise<NeetruSqlClient<TSchema>>;
    get syncState(): SyncState;
    onSyncStateChanged(_cb: (s: SyncState) => void): Unsubscribe;
    flush(): Promise<void>;
    clearCache(): Promise<void>;
    getConflicts(): Promise<ConflictRecord[]>;
    /** Test helper — substitui fixture inteira de uma collection. */
    __setFixture(name: string, items: Record<string, Record<string, unknown>>): void;
    /** Test helper — reset total. */
    __reset(): void;
}

export { DEV_FIXTURE_USER, MockAuth, MockDb, MockEntitlements, MockSupport, MockUsage };
