import { type TestFirestoreContext, type TestingFirestoreDrivers } from '../common/firestore/firestore';
import { type Maybe } from '@dereekb/util';
import { type TestContextBuilderFunction } from '@dereekb/util/test';
import { type TestEnvironmentConfig, type RulesTestEnvironment, type RulesTestContext, type TokenOptions, type EmulatorConfig } from '@firebase/rules-unit-testing';
import { type FirebaseStorage, type Firestore } from '@dereekb/firebase';
import { type TestFirebaseStorageContext, type TestingFirebaseStorageDrivers } from '../common/storage/storage';
import { TestFirebaseContextFixture, type TestFirebaseInstance } from '../common/firebase.instance';
import { type TestFirebaseStorageInstance } from '../common/storage/storage.instance';
/**
 * Combined driver type providing both Firestore and Firebase Storage testing drivers.
 */
export type TestingFirebaseDrivers = TestingFirestoreDrivers & TestingFirebaseStorageDrivers;
/**
 * Configuration for the authenticated context used in rules unit tests.
 *
 * When provided, the test runs as the specified user. When omitted,
 * tests run as an unauthenticated context.
 */
export interface RulesUnitTestingContextConfig {
    readonly userId: string;
    readonly tokenOptions?: Maybe<TokenOptions>;
}
/**
 * Extended {@link TestEnvironmentConfig} with additional options for emulator setup.
 *
 * The `collectionNames` field is required when using testing drivers that fuzz collection names
 * to isolate parallel test runs.
 */
export interface RulesUnitTestingTestEnvironmentConfig extends TestEnvironmentConfig {
    /**
     * List of collection names used in the environment. Is required if using testing drivers.
     */
    readonly collectionNames?: string[];
    readonly firestore?: EmulatorConfig;
    readonly storage?: EmulatorConfig;
}
/**
 * Top-level configuration for {@link firebaseRulesUnitTestBuilder}.
 *
 * Combines the emulator environment config with an optional authenticated context.
 */
export interface RulesUnitTestingConfig {
    readonly testEnvironment: RulesUnitTestingTestEnvironmentConfig;
    readonly rulesContext?: Maybe<RulesUnitTestingContextConfig>;
}
/**
 * Extends {@link TestFirestoreContext} with references to the underlying `@firebase/rules-unit-testing` objects.
 *
 * Useful when a test needs direct access to the rules test environment (e.g., for clearing data or
 * switching auth contexts).
 */
export interface RulesUnitTestTestFirestoreContext extends TestFirestoreContext {
    readonly rulesTestEnvironment: RulesTestEnvironment;
    readonly rulesTestContext: RulesTestContext;
}
/**
 * Creates a {@link TestFirestoreContext} backed by the rules unit testing emulator.
 *
 * Combines the Firestore client drivers with the rules test environment and context
 * to produce a context suitable for client-side Firestore tests.
 */
export declare function makeRulesTestFirestoreContext(drivers: TestingFirestoreDrivers, rulesTestEnvironment: RulesTestEnvironment, rulesTestContext: RulesTestContext): TestFirestoreContext;
/**
 * Extends {@link TestFirebaseStorageContext} with references to the underlying `@firebase/rules-unit-testing` objects.
 */
export interface RulesUnitTestTestFirebaseStorageContext extends TestFirebaseStorageContext {
    readonly rulesTestEnvironment: RulesTestEnvironment;
    readonly rulesTestContext: RulesTestContext;
}
/**
 * Creates a {@link TestFirebaseStorageContext} backed by the rules unit testing emulator.
 *
 * Combines the Storage client drivers with the rules test environment and context
 * to produce a context suitable for client-side Firebase Storage tests.
 */
export declare function makeRulesTestFirebaseStorageContext(drivers: TestingFirebaseStorageDrivers, rulesTestEnvironment: RulesTestEnvironment, rulesTestContext: RulesTestContext): TestFirebaseStorageContext;
/**
 * Test instance that provides both Firestore and Firebase Storage contexts via the
 * `@firebase/rules-unit-testing` emulator.
 *
 * Lazily initializes contexts on first access using {@link cachedGetter}.
 * Used as the instance type for {@link RulesUnitTestFirebaseTestingContextFixture}.
 */
export declare class RulesUnitTestTestFirebaseInstance implements TestFirebaseInstance, TestFirebaseStorageInstance {
    readonly drivers: TestingFirebaseDrivers;
    readonly rulesTestEnvironment: RulesTestEnvironment;
    readonly rulesTestContext: RulesTestContext;
    readonly _firestoreContext: import("@dereekb/util").CachedFactoryWithInput<TestFirestoreContext, unknown>;
    readonly _storageContext: import("@dereekb/util").CachedFactoryWithInput<TestFirebaseStorageContext, unknown>;
    constructor(drivers: TestingFirebaseDrivers, rulesTestEnvironment: RulesTestEnvironment, rulesTestContext: RulesTestContext);
    get firestoreContext(): TestFirestoreContext;
    get storageContext(): TestFirebaseStorageContext;
    get firestore(): Firestore;
    get storage(): FirebaseStorage;
}
/**
 * Concrete {@link TestFirebaseContextFixture} for client-side rules unit tests.
 *
 * Manages the lifecycle of a {@link RulesUnitTestTestFirebaseInstance}, handling
 * setup and teardown of the emulator environment between test suites.
 */
export declare class RulesUnitTestFirebaseTestingContextFixture extends TestFirebaseContextFixture<RulesUnitTestTestFirebaseInstance> {
}
/**
 * A TestContextBuilderFunction for building firebase test context factories using @firebase/firebase and @firebase/rules-unit-testing. This means CLIENT TESTING ONLY. For server testing, look at @dereekb/firestore-server.
 *
 * This can be used to easily build a testing context that sets up RulesTestEnvironment for tests that sets itself up and tears itself down.
 *
 * The {@link RulesTestEnvironment} is initialized once per test suite (`beforeAll`) and cleaned up
 * once (`afterAll`), while fresh drivers and a {@link RulesTestContext} are created per test (`beforeEach`). This avoids
 * repeated calls to `initializeTestEnvironment` (which hits the emulator's `PUT /internal/setRules` endpoint),
 * preventing interference between parallel workers sharing the same Firebase Storage emulator. The Storage
 * emulator maintains rules globally (not per-project), so concurrent `setRules` calls from multiple workers
 * can momentarily leave the emulator in a transitional state that causes `storage/unauthorized` errors.
 */
export declare const firebaseRulesUnitTestBuilder: TestContextBuilderFunction<RulesUnitTestTestFirebaseInstance, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestingConfig>;
/**
 * Registers `beforeAll`/`afterAll` hooks to suppress verbose Firestore log output during tests.
 *
 * Sets the log level to `'error'` before tests and restores it to `'warn'` afterward.
 * Call this at the top level of a `describe` block to reduce test noise.
 */
export declare function changeFirestoreLogLevelBeforeAndAfterTests(): void;