import { type DocumentReference, type DocumentSnapshot, type Transaction as FirebaseFirestoreTransaction, type UpdateData, type WithFieldValue } from 'firebase/firestore';
import { type Observable } from 'rxjs';
import { type FirestoreDocumentDataAccessor, type FirestoreDocumentDataAccessorFactory, type FirestoreDocumentContext, FirestoreDocumentContextType, type SetOptions, type DocumentData, type FirestoreDataConverter, type WriteResult, type FirestoreAccessorIncrementUpdate, type FirestoreAccessorArrayUpdate } from '../../common/firestore';
/**
 * Client-side {@link FirestoreDocumentDataAccessor} that executes all operations within a Firestore `Transaction`.
 *
 * Unlike the default accessor, reads and writes are all routed through the transaction object,
 * providing atomic read-then-write semantics. The `stream()` method emits a single snapshot
 * from the transactional read rather than a live stream.
 */
export declare class TransactionFirestoreDocumentDataAccessor<T> implements FirestoreDocumentDataAccessor<T> {
    private readonly _transaction;
    private readonly _documentRef;
    constructor(transaction: FirebaseFirestoreTransaction, documentRef: DocumentReference<T>);
    get transaction(): FirebaseFirestoreTransaction;
    get documentRef(): DocumentReference<T>;
    stream(): Observable<DocumentSnapshot<T>>;
    create(data: WithFieldValue<T>): Promise<void>;
    exists(): Promise<boolean>;
    get(): Promise<DocumentSnapshot<T>>;
    getWithConverter<U extends DocumentData = DocumentData>(converter: null | FirestoreDataConverter<U>): Promise<DocumentSnapshot<DocumentData, U>>;
    delete(): Promise<void>;
    set(data: WithFieldValue<T>, options?: SetOptions): Promise<void>;
    increment(data: FirestoreAccessorIncrementUpdate<T>): Promise<void | WriteResult>;
    arrayUpdate(data: FirestoreAccessorArrayUpdate<T>): Promise<void | WriteResult>;
    update(data: UpdateData<object>): Promise<void>;
}
/**
 * Creates a {@link FirestoreDocumentDataAccessorFactory} that produces {@link TransactionFirestoreDocumentDataAccessor}
 * instances bound to the given transaction. All operations from these accessors participate in the same transaction.
 *
 * @param transaction - the Firestore `Transaction` to bind operations to
 * @returns a factory that creates transaction-backed document data accessors for any document reference
 *
 * @example
 * ```ts
 * await runTransaction(firestore, async (transaction) => {
 *   const factory = transactionAccessorFactory<MyModel>(transaction);
 *   const accessor = factory.accessorFor(docRef);
 *   const snapshot = await accessor.get();
 *   // ... modify and set
 * });
 * ```
 */
export declare function transactionAccessorFactory<T>(transaction: FirebaseFirestoreTransaction): FirestoreDocumentDataAccessorFactory<T>;
/**
 * Client-side {@link FirestoreDocumentContext} that executes all document operations within a Firestore `Transaction`.
 *
 * Provides accessors with {@link FirestoreDocumentContextType.TRANSACTION} semantics — all reads are
 * consistent and all writes are applied atomically when the transaction completes.
 */
export declare class TransactionFirestoreDocumentContext<T> implements FirestoreDocumentContext<T> {
    private readonly _transaction;
    readonly contextType = FirestoreDocumentContextType.TRANSACTION;
    readonly accessorFactory: FirestoreDocumentDataAccessorFactory<T>;
    constructor(transaction: FirebaseFirestoreTransaction);
    get transaction(): FirebaseFirestoreTransaction;
}
/**
 * Factory function that creates a {@link TransactionFirestoreDocumentContext} for the given transaction.
 *
 * @param transaction - the Firestore `Transaction` to use for all document operations
 * @returns a new {@link TransactionFirestoreDocumentContext} bound to the given transaction
 *
 * @example
 * ```ts
 * const context = transactionDocumentContext<MyModel>(transaction);
 * const accessor = context.accessorFactory.accessorFor(docRef);
 * ```
 */
export declare function transactionDocumentContext<T>(transaction: FirebaseFirestoreTransaction): TransactionFirestoreDocumentContext<T>;