import type { App } from '../app/lifecycle.js';
import { type OrderDirection, type WhereOp } from './rest/query-encoding.js';
import { FirestoreRestClient } from './rest/client.js';
import { FieldPath } from './field-path.js';
import { Filter, type FilterNode } from './filter.js';
import { Timestamp } from './timestamp.js';
export type DocumentData = Record<string, unknown>;
export type SetOptions = {
    merge?: boolean;
    mergeFields?: Array<string | FieldPath>;
};
export type TransactionOptions = {
    maxAttempts?: number;
};
export declare class WriteResult {
    readonly writeTime: Timestamp;
    constructor(writeTime: Timestamp);
}
export declare class SnapshotMetadata {
    readonly fromCache: boolean;
    readonly hasPendingWrites: boolean;
    constructor(fromCache: boolean, hasPendingWrites: boolean);
    isEqual(other: SnapshotMetadata): boolean;
}
export type DocumentSnapshotData<T extends DocumentData> = T;
export declare class DocumentSnapshot<T extends DocumentData = DocumentData> {
    readonly ref: DocumentReference<T>;
    readonly exists: boolean;
    readonly metadata: SnapshotMetadata;
    private readonly _data;
    private readonly _createTime;
    private readonly _updateTime;
    private readonly _readTime;
    constructor(options: {
        ref: DocumentReference<T>;
        exists: boolean;
        data: T | null;
        metadata?: SnapshotMetadata;
        createTime?: Timestamp | null;
        updateTime?: Timestamp | null;
        readTime?: Timestamp | null;
    });
    get id(): string;
    data(): DocumentSnapshotData<T> | undefined;
    get createTime(): Timestamp | undefined;
    get updateTime(): Timestamp | undefined;
    get readTime(): Timestamp | undefined;
    get(fieldPath: string | FieldPath): unknown;
}
export declare class QueryDocumentSnapshot<T extends DocumentData = DocumentData> extends DocumentSnapshot<T> {
    constructor(options: {
        ref: DocumentReference<T>;
        data: T;
        createTime?: Timestamp | null;
        updateTime?: Timestamp | null;
        readTime?: Timestamp | null;
    });
    data(): DocumentSnapshotData<T>;
}
export type DocumentChangeType = 'added' | 'modified' | 'removed';
export type DocumentChange<T extends DocumentData = DocumentData> = {
    type: DocumentChangeType;
    doc: QueryDocumentSnapshot<T>;
    oldIndex: number;
    newIndex: number;
};
export declare class QuerySnapshot<T extends DocumentData = DocumentData> {
    readonly docs: QueryDocumentSnapshot<T>[];
    readonly metadata: SnapshotMetadata;
    private readonly changes;
    constructor(docs: QueryDocumentSnapshot<T>[], options?: {
        metadata?: SnapshotMetadata;
        changes?: Array<DocumentChange<T>>;
    });
    get empty(): boolean;
    get size(): number;
    forEach(callback: (snapshot: QueryDocumentSnapshot<T>) => void): void;
    docChanges(options?: {
        includeMetadataChanges?: boolean;
    }): Array<DocumentChange<T>>;
}
export declare class Firestore {
    private readonly rest;
    private readonly projectId;
    private readonly baseUrl;
    private readonly accessTokenProvider;
    private ignoreUndefinedProperties;
    constructor(options: {
        app: App;
        baseUrl?: string;
    });
    settings(options: {
        ignoreUndefinedProperties?: boolean;
    }): void;
    collection<T extends DocumentData = DocumentData>(collectionPath: string): CollectionReference<T>;
    collectionGroup<T extends DocumentData = DocumentData>(collectionId: string): Query<T>;
    doc<T extends DocumentData = DocumentData>(documentPath: string): DocumentReference<T>;
    batch(): WriteBatch;
    bulkWriter(options?: BulkWriterOptions): BulkWriter;
    bundle(bundleId?: string): BundleBuilder;
    getAll<T extends DocumentData>(...refs: Array<DocumentReference<T>>): Promise<Array<DocumentSnapshot<T>>>;
    listCollections(): Promise<Array<CollectionReference>>;
    runTransaction<T>(updateFn: (tx: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
    _getRestClient(): FirestoreRestClient;
    _getProjectId(): string;
    _getBaseUrl(): string;
    _getAccessToken(): Promise<string | null>;
    _ignoreUndefinedProperties(): boolean;
}
export declare class DocumentReference<T extends DocumentData = DocumentData> {
    readonly firestore: Firestore;
    readonly path: string;
    constructor(options: {
        firestore: Firestore;
        path: string;
    });
    get id(): string;
    get parent(): CollectionReference<T>;
    collection<U extends DocumentData = DocumentData>(collectionPath: string): CollectionReference<U>;
    get(): Promise<DocumentSnapshot<T>>;
    create(data: T): Promise<WriteResult>;
    set(data: T, options?: SetOptions): Promise<WriteResult>;
    update(data: Record<string, unknown>): Promise<WriteResult>;
    update(field: string | FieldPath, value: unknown, ...moreFieldsAndValues: unknown[]): Promise<WriteResult>;
    delete(): Promise<WriteResult>;
    listCollections(): Promise<Array<CollectionReference>>;
    onSnapshot(onNext: (snapshot: DocumentSnapshot<T>) => void, onError?: (error: unknown) => void): () => void;
    onSnapshot(_options: {
        includeMetadataChanges?: boolean;
    }, onNext: (snapshot: DocumentSnapshot<T>) => void, onError?: (error: unknown) => void): () => void;
    private writeUpdate;
}
type CursorConstraint = {
    kind: 'values';
    inclusive: boolean;
    values: unknown[];
} | {
    kind: 'snapshot';
    inclusive: boolean;
    snapshot: DocumentSnapshot;
};
export declare class Query<T extends DocumentData = DocumentData> {
    readonly firestore: Firestore;
    protected readonly collectionPath: string;
    private readonly whereFilter;
    private readonly orderByClauses;
    private readonly limitValue;
    private readonly limitToLastValue;
    private readonly offsetValue;
    private readonly selectFieldPaths;
    private readonly allDescendants;
    private readonly startAtBound;
    private readonly endAtBound;
    constructor(options: {
        firestore: Firestore;
        collectionPath: string;
        where?: FilterNode | null;
        orderBy?: Array<{
            fieldPath: string;
            direction: OrderDirection;
        }>;
        limit?: number | null;
        limitToLast?: boolean;
        offset?: number | null;
        select?: string[] | null;
        allDescendants?: boolean;
        startAt?: CursorConstraint | null;
        endAt?: CursorConstraint | null;
    });
    where(fieldPath: string | FieldPath, op: WhereOp, value: unknown): Query<T>;
    where(filter: Filter): Query<T>;
    orderBy(fieldPath: string | FieldPath, direction?: OrderDirection): Query<T>;
    limit(limit: number): Query<T>;
    limitToLast(limit: number): Query<T>;
    offset(offset: number): Query<T>;
    select(...fieldPaths: Array<string | FieldPath>): Query<T>;
    startAt(snapshot: DocumentSnapshot<T>): Query<T>;
    startAt(...fieldValues: unknown[]): Query<T>;
    startAfter(snapshot: DocumentSnapshot<T>): Query<T>;
    startAfter(...fieldValues: unknown[]): Query<T>;
    endAt(snapshot: DocumentSnapshot<T>): Query<T>;
    endAt(...fieldValues: unknown[]): Query<T>;
    endBefore(snapshot: DocumentSnapshot<T>): Query<T>;
    endBefore(...fieldValues: unknown[]): Query<T>;
    getPartitions(desiredPartitionCount: number): AsyncIterable<QueryPartition<T>>;
    private _buildStructuredQueryRequest;
    get(): Promise<QuerySnapshot<T>>;
    onSnapshot(onNext: (snapshot: QuerySnapshot<T>) => void, onError?: (error: unknown) => void): () => void;
    onSnapshot(_options: {
        includeMetadataChanges?: boolean;
    }, onNext: (snapshot: QuerySnapshot<T>) => void, onError?: (error: unknown) => void): () => void;
    count(): AggregateQuery<T>;
    aggregate(aggregations: Record<string, AggregateField>): AggregateQuery<T>;
}
export declare class AggregateField {
    private readonly kind;
    private readonly fieldPath;
    private constructor();
    static count(): AggregateField;
    static sum(fieldPath: string | FieldPath): AggregateField;
    static average(fieldPath: string | FieldPath): AggregateField;
    _encode(alias: string): unknown;
}
export declare class AggregateQuerySnapshot {
    private readonly snapshotData;
    private readonly snapshotReadTime;
    constructor(options: {
        data: Record<string, unknown>;
        readTime?: Timestamp | null;
    });
    data(): Record<string, unknown>;
    get readTime(): Timestamp | undefined;
}
export declare class AggregateQuery<T extends DocumentData = DocumentData> {
    readonly query: Query<T>;
    private readonly parentResourceName;
    private readonly structuredQuery;
    private readonly aggregations;
    constructor(options: {
        query: Query<T>;
        parentResourceName: string;
        structuredQuery: unknown;
        aggregations: unknown[];
    });
    get(): Promise<AggregateQuerySnapshot>;
}
export declare class QueryPartition<T extends DocumentData = DocumentData> {
    private readonly baseQuery;
    private readonly startAtValues;
    private readonly endBeforeValues;
    constructor(options: {
        query: Query<T>;
        startAt?: unknown[] | undefined;
        endBefore?: unknown[] | undefined;
    });
    get startAt(): unknown[] | undefined;
    get endBefore(): unknown[] | undefined;
    toQuery(): Query<T>;
}
export declare class CollectionReference<T extends DocumentData = DocumentData> extends Query<T> {
    readonly path: string;
    constructor(options: {
        firestore: Firestore;
        path: string;
    });
    get id(): string;
    get parent(): DocumentReference | null;
    doc(documentId: string): DocumentReference<T>;
    add(data: T): Promise<DocumentReference<T>>;
    listDocuments(options?: {
        pageSize?: number;
    }): Promise<Array<DocumentReference<T>>>;
}
export declare class WriteBatch {
    private readonly firestore;
    private readonly writes;
    constructor(firestore: Firestore);
    create<T extends DocumentData>(ref: DocumentReference<T>, data: T): this;
    set<T extends DocumentData>(ref: DocumentReference<T>, data: T, options?: SetOptions): this;
    update<T extends DocumentData>(ref: DocumentReference<T>, data: Record<string, unknown>): this;
    update<T extends DocumentData>(ref: DocumentReference<T>, field: string | FieldPath, value: unknown, ...moreFieldsAndValues: unknown[]): this;
    delete<T extends DocumentData>(ref: DocumentReference<T>): this;
    commit(): Promise<WriteResult[]>;
}
export type BulkWriterOptions = {
    throttling?: boolean | {
        initialOpsPerSecond?: number;
        maxOpsPerSecond?: number;
    };
};
export declare class BulkWriterError extends Error {
    readonly code: number;
    readonly documentRef: DocumentReference;
    readonly operationType: 'create' | 'set' | 'update' | 'delete';
    readonly failedAttempts: number;
    constructor(options: {
        code: number;
        message: string;
        documentRef: DocumentReference;
        operationType: 'create' | 'set' | 'update' | 'delete';
        failedAttempts: number;
    });
}
export declare class BulkWriter {
    private readonly firestore;
    private readonly queue;
    private readonly pendingOpIds;
    private readonly flushWaiters;
    private readonly writeResultListeners;
    private writeErrorListener;
    private nextOpId;
    private scheduled;
    private processing;
    private closed;
    private batchWriteDisabled;
    private readonly maxBatchSize;
    private readonly maxAttempts;
    constructor(firestore: Firestore, options?: BulkWriterOptions);
    private ensureOpen;
    onWriteResult(callback: (documentRef: DocumentReference, result: WriteResult) => void): void;
    onWriteError(shouldRetryCallback: (error: BulkWriterError) => boolean): void;
    create<T extends DocumentData>(documentRef: DocumentReference<T>, data: T): Promise<WriteResult>;
    set<T extends DocumentData>(documentRef: DocumentReference<T>, data: T): Promise<WriteResult>;
    set<T extends DocumentData>(documentRef: DocumentReference<T>, data: Partial<T>, options: SetOptions): Promise<WriteResult>;
    update<T extends DocumentData>(documentRef: DocumentReference<T>, data: Record<string, unknown>): Promise<WriteResult>;
    update(documentRef: DocumentReference, field: string | FieldPath, value: unknown, ...moreFieldsAndValues: unknown[]): Promise<WriteResult>;
    delete(documentRef: DocumentReference): Promise<WriteResult>;
    flush(): Promise<void>;
    close(): Promise<void>;
    private enqueue;
    private schedule;
    private notifyFlushWaiters;
    private takeBatch;
    private processQueue;
    private processBatchViaCommit;
    private processBatch;
}
export declare class BundleBuilder {
    readonly bundleId: string;
    constructor(bundleId: string);
    add(snapshotOrName: unknown, maybeSnapshot?: unknown): this;
    build(): Uint8Array;
}
export declare class Transaction {
    private readonly firestore;
    private readonly transactionId;
    private readonly writes;
    private didWrite;
    constructor(firestore: Firestore, transactionId: string);
    get<T extends DocumentData>(ref: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
    set<T extends DocumentData>(ref: DocumentReference<T>, data: T, options?: SetOptions): this;
    create<T extends DocumentData>(ref: DocumentReference<T>, data: T): this;
    update<T extends DocumentData>(ref: DocumentReference<T>, data: Record<string, unknown>): this;
    update<T extends DocumentData>(ref: DocumentReference<T>, field: string | FieldPath, value: unknown, ...moreFieldsAndValues: unknown[]): this;
    delete<T extends DocumentData>(ref: DocumentReference<T>): this;
    commit(): Promise<void>;
}
export declare function getFirestore(app?: App): Firestore;
export {};
//# sourceMappingURL=firestore.d.ts.map