@firebase/firestore 3.5.0 → 3.6.0-20220929164943

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @firebase/firestore
 
+## 3.6.0-20220929164943
+
+### Minor Changes
+
+- [`e35db6f95`](https://github.com/firebase/firebase-js-sdk/commit/e35db6f955f1b712ff67a991d8291352f28708e2) [#6597](https://github.com/firebase/firebase-js-sdk/pull/6597) - Implement count query for internal use.
+
+* [`ee871fc0b`](https://github.com/firebase/firebase-js-sdk/commit/ee871fc0b157e1a186c2895b4290d70c8d1b986f) [#6608](https://github.com/firebase/firebase-js-sdk/pull/6608) - Added `getCountFromServer()` (`getCount()` in the Lite SDK), which fetches the number of documents in the result set without actually downloading the documents.
+
+### Patch Changes
+
+- [`fdd4ab464`](https://github.com/firebase/firebase-js-sdk/commit/fdd4ab464b59a107bdcc195df3f01e32efd89ed4) [#6526](https://github.com/firebase/firebase-js-sdk/pull/6526) - Add functionality to auto-initialize project config and emulator settings from global defaults provided by framework tooling.
+
+* [`c6ba6fc0f`](https://github.com/firebase/firebase-js-sdk/commit/c6ba6fc0f44178d56fe165f71a798663516a2904) [#6619](https://github.com/firebase/firebase-js-sdk/pull/6619) - Fix a time travel issue across multiple tabs
+
+* Updated dependencies [[`fdd4ab464`](https://github.com/firebase/firebase-js-sdk/commit/fdd4ab464b59a107bdcc195df3f01e32efd89ed4)]:
+  - @firebase/app@0.8.0-20220929164943
+  - @firebase/util@1.7.0-20220929164943
+  - @firebase/component@0.5.18-20220929164943
+
 ## 3.5.0
 
 ### Minor Changes

package/dist/firestore/lite/index.d.ts

@@ -6,6 +6,8 @@
  * directly to the backend, and `onSnapshot()` APIs are not supported.
  * @packageDocumentation
  */
+export { aggregateQuerySnapshotEqual, getCount } from '../src/lite-api/aggregate';
+export { AggregateField, AggregateFieldType, AggregateSpec, AggregateSpecData, AggregateQuerySnapshot } from '../src/lite-api/aggregate_types';
 export { FirestoreSettings as Settings } from '../src/lite-api/settings';
 export { Firestore as Firestore, EmulatorMockTokenOptions, initializeFirestore, getFirestore, terminate, connectFirestoreEmulator } from '../src/lite-api/database';
 export { DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, SetOptions, DocumentReference, Query, CollectionReference, collection, collectionGroup, doc, refEqual, queryEqual } from '../src/lite-api/reference';

package/dist/firestore/src/api/aggregate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Query } from '../api';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate_types';
+export { aggregateQuerySnapshotEqual } from '../lite-api/aggregate';
+/**
+ * Calculates the number of documents in the result set of the given query,
+ * without actually downloading the documents.
+ *
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can even
+ * count the documents if the result set would be prohibitively large to
+ * download entirely (e.g. thousands of documents).
+ *
+ * The result received from the server is presented, unaltered, without
+ * considering any local state. That is, documents in the local cache are not
+ * taken into consideration, neither are local modifications not yet
+ * synchronized with the server. Previously-downloaded results, if any, are not
+ * used: every request using this source necessarily involves a round trip to
+ * the server.
+ *
+ * @param query - The query whose result set size to calculate.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
+ */
+export declare function getCountFromServer(query: Query<unknown>): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}>>;

package/dist/firestore/src/api/database.d.ts

@@ -39,7 +39,7 @@ export declare const CACHE_SIZE_UNLIMITED = -1;
 /**
  * The Cloud Firestore service interface.
  *
- * Do not call this constructor directly. Instead, use {@link getFirestore}.
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
  */
 export declare class Firestore extends LiteFirestore {
     /**
@@ -56,8 +56,8 @@ export declare class Firestore extends LiteFirestore {
 /**
  * Initializes a new instance of {@link Firestore} with the provided settings.
  * Can only be called before any other function, including
- * {@link getFirestore}. If the custom settings are empty, this function is
- * equivalent to calling {@link getFirestore}.
+ * {@link (getFirestore:1)}. If the custom settings are empty, this function is
+ * equivalent to calling {@link (getFirestore:1)}.
  *
  * @param app - The {@link @firebase/app#FirebaseApp} with which the {@link Firestore} instance will
  * be associated.
@@ -66,14 +66,6 @@ export declare class Firestore extends LiteFirestore {
  * @returns A newly initialized {@link Firestore} instance.
  */
 export declare function initializeFirestore(app: FirebaseApp, settings: FirestoreSettings, databaseId?: string): Firestore;
-/**
- * Returns the existing default {@link Firestore} instance that is associated with the
- * default {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
- * instance with default settings.
- *
- * @returns The {@link Firestore} instance of the provided app.
- */
-export declare function getFirestore(): Firestore;
 /**
  * Returns the existing default {@link Firestore} instance that is associated with the
  * provided {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
@@ -95,7 +87,15 @@ export declare function getFirestore(app: FirebaseApp): Firestore;
  */
 export declare function getFirestore(databaseId: string): Firestore;
 /**
- * Returns the existing {@link Firestore} instance that is associated with the
+ * Returns the existing default {@link Firestore} instance that is associated with the
+ * default {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @returns The {@link Firestore} instance of the provided app.
+ */
+export declare function getFirestore(): Firestore;
+/**
+ * Returns the existing default {@link Firestore} instance that is associated with the
  * provided {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
  * instance with default settings.
  *
@@ -115,7 +115,7 @@ export declare function configureFirestore(firestore: Firestore): void;
  * Attempts to enable persistent storage, if possible.
  *
  * Must be called before any other functions (other than
- * {@link initializeFirestore}, {@link getFirestore} or
+ * {@link initializeFirestore}, {@link (getFirestore:1)} or
  * {@link clearIndexedDbPersistence}.
  *
  * If this fails, `enableIndexedDbPersistence()` will reject the promise it
@@ -165,7 +165,7 @@ export declare function enableMultiTabIndexedDbPersistence(firestore: Firestore)
  * Must be called while the {@link Firestore} instance is not started (after the app is
  * terminated or when the app is first initialized). On startup, this function
  * must be called before other functions (other than {@link
- * initializeFirestore} or {@link getFirestore})). If the {@link Firestore}
+ * initializeFirestore} or {@link (getFirestore:1)})). If the {@link Firestore}
  * instance is still running, the promise will be rejected with the error code
  * of `failed-precondition`.
  *
@@ -221,7 +221,7 @@ export declare function disableNetwork(firestore: Firestore): Promise<void>;
  * may be used. Any other function will throw a `FirestoreError`.
  *
  * To restart after termination, create a new instance of FirebaseFirestore with
- * {@link getFirestore}.
+ * {@link (getFirestore:1)}.
  *
  * Termination does not cancel any pending writes, and any promises that are
  * awaiting a response from the server will not be resolved. If you have

package/dist/firestore/src/api.d.ts

@@ -14,6 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export { aggregateQuerySnapshotEqual, getCountFromServer } from './api/aggregate';
+export { AggregateField, AggregateFieldType, AggregateSpec, AggregateSpecData, AggregateQuerySnapshot } from './lite-api/aggregate_types';
 export { FieldPath, documentId } from './api/field_path';
 export { Firestore, EmulatorMockTokenOptions, initializeFirestore, getFirestore, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, clearIndexedDbPersistence, waitForPendingWrites, disableNetwork, enableNetwork, terminate, connectFirestoreEmulator, loadBundle, namedQuery, ensureFirestoreConfigured } from './api/database';
 export { LoadBundleTask, LoadBundleTaskProgress, TaskState } from './api/bundle';

package/dist/firestore/src/core/count_query_runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AbstractUserDataWriter, Query } from '../api';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate_types';
+import { Datastore } from '../remote/datastore';
+/**
+ * CountQueryRunner encapsulates the logic needed to run the count aggregation
+ * queries.
+ */
+export declare class CountQueryRunner {
+    private readonly query;
+    private readonly datastore;
+    private readonly userDataWriter;
+    constructor(query: Query<unknown>, datastore: Datastore, userDataWriter: AbstractUserDataWriter);
+    run(): Promise<AggregateQuerySnapshot<{
+        count: AggregateField<number>;
+    }>>;
+}

package/dist/firestore/src/core/firestore_client.d.ts

@@ -15,9 +15,11 @@
  * limitations under the License.
  */
 import { GetOptions } from '@firebase/firestore-types';
+import { AbstractUserDataWriter, AggregateField, AggregateQuerySnapshot } from '../api';
 import { LoadBundleTask } from '../api/bundle';
 import { CredentialsProvider } from '../api/credentials';
 import { User } from '../auth/user';
+import { Query as LiteQuery } from '../lite-api/reference';
 import { LocalStore } from '../local/local_store';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
@@ -115,5 +117,8 @@ export declare function firestoreClientAddSnapshotsInSyncListener(client: Firest
  * performed before any writes. Transactions must be performed while online.
  */
 export declare function firestoreClientTransaction<T>(client: FirestoreClient, updateFunction: (transaction: Transaction) => Promise<T>, options: TransactionOptions): Promise<T>;
+export declare function firestoreClientRunCountQuery(client: FirestoreClient, query: LiteQuery<unknown>, userDataWriter: AbstractUserDataWriter): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}>>;
 export declare function firestoreClientLoadBundle(client: FirestoreClient, databaseId: DatabaseId, data: ReadableStream<Uint8Array> | ArrayBuffer | string, resultTask: LoadBundleTask): void;
 export declare function firestoreClientGetNamedQuery(client: FirestoreClient, queryName: string): Promise<NamedQuery | undefined>;

package/dist/firestore/src/lite-api/aggregate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AggregateField, AggregateQuerySnapshot, AggregateSpec } from './aggregate_types';
+import { Query } from './reference';
+/**
+ * Calculates the number of documents in the result set of the given query,
+ * without actually downloading the documents.
+ *
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can even
+ * count the documents if the result set would be prohibitively large to
+ * download entirely (e.g. thousands of documents).
+ *
+ * @param query - The query whose result set size to calculate.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
+ */
+export declare function getCount(query: Query<unknown>): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}>>;
+/**
+ * Compares two `AggregateQuerySnapshot` instances for equality.
+ *
+ * Two `AggregateQuerySnapshot` instances are considered "equal" if they have
+ * underlying queries that compare equal, and the same data.
+ *
+ * @param left - The first `AggregateQuerySnapshot` to compare.
+ * @param right - The second `AggregateQuerySnapshot` to compare.
+ *
+ * @returns `true` if the objects are "equal", as defined above, or `false`
+ * otherwise.
+ */
+export declare function aggregateQuerySnapshotEqual<T extends AggregateSpec>(left: AggregateQuerySnapshot<T>, right: AggregateQuerySnapshot<T>): boolean;

package/dist/firestore/src/lite-api/aggregate_types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Query } from './reference';
+/**
+ * Represents an aggregation that can be performed by Firestore.
+ */
+export declare class AggregateField<T> {
+    /** A type string to uniquely identify instances of this class. */
+    type: string;
+}
+/**
+ * The union of all `AggregateField` types that are supported by Firestore.
+ */
+export declare type AggregateFieldType = AggregateField<number>;
+/**
+ * A type whose property values are all `AggregateField` objects.
+ */
+export interface AggregateSpec {
+    [field: string]: AggregateFieldType;
+}
+/**
+ * A type whose keys are taken from an `AggregateSpec`, and whose values are the
+ * result of the aggregation performed by the corresponding `AggregateField`
+ * from the input `AggregateSpec`.
+ */
+export declare type AggregateSpecData<T extends AggregateSpec> = {
+    [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
+};
+/**
+ * The results of executing an aggregation query.
+ */
+export declare class AggregateQuerySnapshot<T extends AggregateSpec> {
+    private readonly _data;
+    /** A type string to uniquely identify instances of this class. */
+    readonly type = "AggregateQuerySnapshot";
+    /**
+     * The underlying query over which the aggregations recorded in this
+     * `AggregateQuerySnapshot` were performed.
+     */
+    readonly query: Query<unknown>;
+    /** @hideconstructor */
+    constructor(query: Query<unknown>, _data: AggregateSpecData<T>);
+    /**
+     * Returns the results of the aggregations performed over the underlying
+     * query.
+     *
+     * The keys of the returned object will be the same as those of the
+     * `AggregateSpec` object specified to the aggregation method, and the values
+     * will be the corresponding aggregation result.
+     *
+     * @returns The results of the aggregations performed over the underlying
+     * query.
+     */
+    data(): AggregateSpecData<T>;
+}

package/dist/firestore/src/lite-api/database.d.ts

@@ -21,6 +21,7 @@ import { User } from '../auth/user';
 import { DatabaseId } from '../core/database_info';
 import { FirestoreService } from './components';
 import { FirestoreSettingsImpl, PrivateSettings, FirestoreSettings } from './settings';
+export { EmulatorMockTokenOptions } from '@firebase/util';
 declare module '@firebase/component' {
     interface NameServiceMapping {
         'firestore/lite': Firestore;
@@ -29,7 +30,7 @@ declare module '@firebase/component' {
 /**
  * The Cloud Firestore service interface.
  *
- * Do not call this constructor directly. Instead, use {@link getFirestore}.
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
  */
 export declare class Firestore implements FirestoreService {
     _authCredentials: CredentialsProvider<User>;
@@ -71,8 +72,8 @@ export declare class Firestore implements FirestoreService {
 /**
  * Initializes a new instance of Cloud Firestore with the provided settings.
  * Can only be called before any other functions, including
- * {@link getFirestore}. If the custom settings are empty, this function is
- * equivalent to calling {@link getFirestore}.
+ * {@link (getFirestore:1)}. If the custom settings are empty, this function is
+ * equivalent to calling {@link (getFirestore:1)}.
  *
  * @param app - The {@link @firebase/app#FirebaseApp} with which the `Firestore` instance will
  * be associated.
@@ -83,8 +84,8 @@ export declare function initializeFirestore(app: FirebaseApp, settings: Firestor
 /**
  * Initializes a new instance of Cloud Firestore with the provided settings.
  * Can only be called before any other functions, including
- * {@link getFirestore}. If the custom settings are empty, this function is
- * equivalent to calling {@link getFirestore}.
+ * {@link (getFirestore:1)}. If the custom settings are empty, this function is
+ * equivalent to calling {@link (getFirestore:1)}.
  *
  * @param app - The {@link @firebase/app#FirebaseApp} with which the `Firestore` instance will
  * be associated.
@@ -134,7 +135,6 @@ export declare function getFirestore(databaseId: string): Firestore;
  * @internal
  */
 export declare function getFirestore(app: FirebaseApp, databaseId: string): Firestore;
-export { EmulatorMockTokenOptions } from '@firebase/util';
 /**
  * Modify this instance to communicate with the Cloud Firestore emulator.
  *
@@ -160,7 +160,7 @@ export declare function connectFirestoreEmulator(firestore: Firestore, host: str
  * response from the server will not be resolved.
  *
  * To restart after termination, create a new instance of `Firestore` with
- * {@link getFirestore}.
+ * {@link (getFirestore:1)}.
  *
  * Note: Under normal circumstances, calling `terminate()` is not required. This
  * function is useful only when you want to force this instance to release all of

package/dist/firestore/src/platform/node/grpc_connection.d.ts

@@ -26,6 +26,7 @@ export declare class GrpcConnection implements Connection {
     private readonly databasePath;
     private readonly firestore;
     private cachedStub;
+    get shouldResourcePathBeIncludedInRequest(): boolean;
     constructor(protos: grpc.GrpcObject, databaseInfo: DatabaseInfo);
     private ensureActiveStub;
     invokeRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp>;

package/dist/firestore/src/protos/firestore_proto_api.d.ts

@@ -295,6 +295,32 @@ export declare namespace firestoreV1ApiClientInterfaces {
         readTime?: string;
         skippedResults?: number;
     }
+    interface RunAggregationQueryRequest {
+        parent?: string;
+        structuredAggregationQuery?: StructuredAggregationQuery;
+        transaction?: string;
+        newTransaction?: TransactionOptions;
+        readTime?: string;
+    }
+    interface RunAggregationQueryResponse {
+        result?: AggregationResult;
+        transaction?: string;
+        readTime?: string;
+    }
+    interface AggregationResult {
+        aggregateFields?: ApiClientObjectMap<Value>;
+    }
+    interface StructuredAggregationQuery {
+        structuredQuery?: StructuredQuery;
+        aggregations?: Aggregation[];
+    }
+    interface Aggregation {
+        count?: Count;
+        alias?: string;
+    }
+    interface Count {
+        upTo?: number;
+    }
     interface Status {
         code?: number;
         message?: string;
@@ -417,6 +443,8 @@ export declare type ReadWrite = firestoreV1ApiClientInterfaces.ReadWrite;
 export declare type RollbackRequest = firestoreV1ApiClientInterfaces.RollbackRequest;
 export declare type RunQueryRequest = firestoreV1ApiClientInterfaces.RunQueryRequest;
 export declare type RunQueryResponse = firestoreV1ApiClientInterfaces.RunQueryResponse;
+export declare type RunAggregationQueryRequest = firestoreV1ApiClientInterfaces.RunAggregationQueryRequest;
+export declare type RunAggregationQueryResponse = firestoreV1ApiClientInterfaces.RunAggregationQueryResponse;
 export declare type Status = firestoreV1ApiClientInterfaces.Status;
 export declare type StructuredQuery = firestoreV1ApiClientInterfaces.StructuredQuery;
 export declare type Target = firestoreV1ApiClientInterfaces.Target;

package/dist/firestore/src/remote/connection.d.ts

@@ -62,6 +62,13 @@ export interface Connection {
      * @param token - the Token to use for the RPC.
      */
     openStream<Req, Resp>(rpcName: string, authToken: Token | null, appCheckToken: Token | null): Stream<Req, Resp>;
+    /**
+     * Returns whether or not the implementation requires that the "path" of the resource
+     * (a document or a collection) be present in the request message. If true, then the
+     * request message must include the path. If false, then the request message must NOT
+     * include the path.
+     */
+    readonly shouldResourcePathBeIncludedInRequest: boolean;
 }
 /**
  * A bidirectional stream that can be used to send an receive messages.

package/dist/firestore/src/remote/datastore.d.ts

@@ -20,6 +20,7 @@ import { Query } from '../core/query';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { Mutation } from '../model/mutation';
+import { Value as ProtoValue } from '../protos/firestore_proto_api';
 import { AsyncQueue } from '../util/async_queue';
 import { Connection } from './connection';
 import { PersistentListenStream, PersistentWriteStream, WatchStreamListener, WriteStreamListener } from './persistent_stream';
@@ -36,5 +37,6 @@ export declare function newDatastore(authCredentials: CredentialsProvider<User>,
 export declare function invokeCommitRpc(datastore: Datastore, mutations: Mutation[]): Promise<void>;
 export declare function invokeBatchGetDocumentsRpc(datastore: Datastore, keys: DocumentKey[]): Promise<Document[]>;
 export declare function invokeRunQueryRpc(datastore: Datastore, query: Query): Promise<Document[]>;
+export declare function invokeRunAggregationQueryRpc(datastore: Datastore, query: Query): Promise<ProtoValue[]>;
 export declare function newPersistentWriteStream(datastore: Datastore, queue: AsyncQueue, listener: WriteStreamListener): PersistentWriteStream;
 export declare function newPersistentWatchStream(datastore: Datastore, queue: AsyncQueue, listener: WatchStreamListener): PersistentListenStream;

package/dist/firestore/src/remote/rest_connection.d.ts

@@ -27,6 +27,7 @@ export declare abstract class RestConnection implements Connection {
     protected readonly databaseId: DatabaseId;
     protected readonly baseUrl: string;
     private readonly databaseRoot;
+    get shouldResourcePathBeIncludedInRequest(): boolean;
     constructor(databaseInfo: DatabaseInfo);
     invokeRPC<Req, Resp>(rpcName: string, path: string, req: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp>;
     invokeStreamingRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null, expectedResponseCount?: number): Promise<Resp[]>;

package/dist/firestore/src/remote/serializer.d.ts

@@ -26,7 +26,7 @@ import { FieldMask } from '../model/field_mask';
 import { Mutation, MutationResult } from '../model/mutation';
 import { ObjectValue } from '../model/object_value';
 import { FieldPath, ResourcePath } from '../model/path';
-import { ApiClientObjectMap as ProtoApiClientObjectMap, BatchGetDocumentsResponse as ProtoBatchGetDocumentsResponse, Document as ProtoDocument, DocumentMask as ProtoDocumentMask, DocumentsTarget as ProtoDocumentsTarget, FieldFilterOp as ProtoFieldFilterOp, FieldReference as ProtoFieldReference, Filter as ProtoFilter, ListenResponse as ProtoListenResponse, Order as ProtoOrder, OrderDirection as ProtoOrderDirection, QueryTarget as ProtoQueryTarget, Target as ProtoTarget, Timestamp as ProtoTimestamp, Write as ProtoWrite, WriteResult as ProtoWriteResult } from '../protos/firestore_proto_api';
+import { ApiClientObjectMap as ProtoApiClientObjectMap, BatchGetDocumentsResponse as ProtoBatchGetDocumentsResponse, Document as ProtoDocument, DocumentMask as ProtoDocumentMask, DocumentsTarget as ProtoDocumentsTarget, FieldFilterOp as ProtoFieldFilterOp, FieldReference as ProtoFieldReference, Filter as ProtoFilter, ListenResponse as ProtoListenResponse, Order as ProtoOrder, OrderDirection as ProtoOrderDirection, QueryTarget as ProtoQueryTarget, RunAggregationQueryRequest as ProtoRunAggregationQueryRequest, Target as ProtoTarget, Timestamp as ProtoTimestamp, Write as ProtoWrite, WriteResult as ProtoWriteResult } from '../protos/firestore_proto_api';
 import { ByteString } from '../util/byte_string';
 import { Serializer } from './number_serializer';
 import { WatchChange } from './watch_change';
@@ -82,6 +82,7 @@ export declare function fromWriteResults(protos: ProtoWriteResult[] | undefined,
 export declare function toDocumentsTarget(serializer: JsonProtoSerializer, target: Target): ProtoDocumentsTarget;
 export declare function fromDocumentsTarget(documentsTarget: ProtoDocumentsTarget): Target;
 export declare function toQueryTarget(serializer: JsonProtoSerializer, target: Target): ProtoQueryTarget;
+export declare function toRunAggregationQueryRequest(serializer: JsonProtoSerializer, target: Target): ProtoRunAggregationQueryRequest;
 export declare function convertQueryTargetToQuery(target: ProtoQueryTarget): Query;
 export declare function fromQueryTarget(target: ProtoQueryTarget): Target;
 export declare function toListenRequestLabels(serializer: JsonProtoSerializer, targetData: TargetData): ProtoApiClientObjectMap<string> | null;

package/dist/firestore/test/integration/api/aggregation.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/dist/firestore/test/integration/api_internal/aggregation.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/dist/firestore/test/integration/util/helpers.d.ts

@@ -44,6 +44,7 @@ export declare function withTestDocAndInitialData(persistence: boolean, initialD
 export declare function withTestCollection(persistence: boolean, docs: {
     [key: string]: DocumentData;
 }, fn: (collection: CollectionReference, db: Firestore) => Promise<void>): Promise<void>;
+export declare function withEmptyTestCollection(persistence: boolean, fn: (collection: CollectionReference, db: Firestore) => Promise<void>): Promise<void>;
 export declare function withTestCollectionSettings(persistence: boolean, settings: PrivateSettings, docs: {
     [key: string]: DocumentData;
 }, fn: (collection: CollectionReference, db: Firestore) => Promise<void>): Promise<void>;

package/dist/firestore/test/unit/specs/spec_test_components.d.ts

@@ -96,6 +96,7 @@ export declare class MockConnection implements Connection {
     writeStreamRequestCount: number;
     nextWriteStreamToken: number;
     constructor(queue: AsyncQueue);
+    shouldResourcePathBeIncludedInRequest: boolean;
     /**
      * Tracks the currently active watch targets as detected by the mock watch
      * stream, as a mapping from target ID to query Target.