@squidcloud/client 1.0.127 → 1.0.129

package/dist/typescript-client/src/collection-reference.d.ts

@@ -1,80 +1,80 @@
-import { Alias, DocId, DocIdObj, DocumentData, SnapshotEmitter } from '@squidcloud/common';
-import { DocumentReference } from './document-reference';
-import { JoinQueryBuilder } from './query/join-query-builder.factory';
-import { QueryBuilder } from './query/query-builder.factory';
-/**
- *  Holds a reference to a data collection. A collection reference is a reference to a collection in a database. You
- * can use it to read or write data to the collection. A collection can refer to a table in a relational database or a
- * collection in a NoSQL database.
- *
- * Read more about collection references in the
- * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/collection-reference documentation}.
- * @typeParam T The type of the document data.
- */
-export declare class CollectionReference<T extends DocumentData> {
-    private readonly collectionName;
-    private integrationId;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly querySubscriptionManager;
-    /** A string that uniquely identifies this collection reference. */
-    refId: string;
-    /**
-     * Returns a document reference for the given document id.
-     * The document id is an object that maps the primary keys of the collection (as defined in the Squid Cloud Console)
-     * to their values. There are a few exceptions:
-     * 1 - String document id is only supported for the `built_in_db` when a schema was not defined.
-     * 2 - Not all the fields in the document id are required. If a field is not provided, it will be generated on the
-     *     server once the document is created (if the integration supports it).
-     * 3 - When a document id is not provided, it will be treated as an empty object or empty string.
-     * 4 - When the document id is just a `string` and not provided (applies only for the `built_in_db`), it will be
-     *    generated on the server.
-     * 5 - If the collection in the `built_in_db` does not have a schema, the document id must be provided as a string.
-     *
-     * Examples:
-     * ```typescript
-     * // For a collection in the built_in_db that does not have a schema
-     * const docRef = collectionRef.doc('my-doc-id');
-     * const docRef = collectionRef.doc({id: my-doc-id'});
-     *
-     * // For a collection with a single primary key field called "id"
-     * const docRef = collectionRef.doc({id: 'my-doc-id'});
-     *
-     * // For a collection with a composite primary key
-     * const docRef = collectionRef.doc({id1: 'my-doc-id1', id2: 'my-doc-id2'});
-     * const docRef = collectionRef.doc({id1: 'my-doc-id1'}); // id2 will be generated on the server if the integration
-     * supports it
-     *
-     * // For a collection from the `built_in_db` without a defined schema when an id is not provided
-     *  const docRef = collectionRef.doc(); // The id will be generated on the server
-     * ```
-     *
-     * @param docId The document id as an object for the different fields in the primary key or a string.
-     * @returns A document reference for the given document id.
-     */
-    doc(docId?: DocId | DocIdObj): DocumentReference<T>;
-    /**
-     * Creates a `QueryBuilder` that can be used to query the collection.
-     *
-     * @returns A `QueryBuilder` that can be used to query the collection.
-     */
-    query(): QueryBuilder<T>;
-    /**
-     * Creates a `JoinQueryBuilder` that can be used to query the collection
-     * Note that when using a join query, you have to provide an alias for the query and for every other query
-     * participating in the join.
-     *
-     * @param alias The alias for the query.
-     * @returns A `JoinQueryBuilder` that can be used to query the collection and joins with other queries.
-     */
-    joinQuery<A extends Alias>(alias: A): JoinQueryBuilder<Record<A, []>, Record<A, T>, A, A>;
-    /**
-     * Performs `or` on a list of queries. All the queries need to be on the same collection.
-     * The result will be a merge of all the queries sorted by the same sort condition of the first query.
-     * Duplicate items will be removed.
-     * @param builders The list of query builders to merge. (A query builder can be returned from the {@link query}
-     *   method).
-     * @returns A query builder that can be used to perform the `or` operation.
-     */
-    or(...builders: QueryBuilder<T>[]): SnapshotEmitter<DocumentReference<T>>;
-}
+import { Alias, DocId, DocIdObj, DocumentData, SnapshotEmitter } from '@squidcloud/common';
+import { DocumentReference } from './document-reference';
+import { JoinQueryBuilder } from './query/join-query-builder.factory';
+import { QueryBuilder } from './query/query-builder.factory';
+/**
+ *  Holds a reference to a data collection. A collection reference is a reference to a collection in a database. You
+ * can use it to read or write data to the collection. A collection can refer to a table in a relational database or a
+ * collection in a NoSQL database.
+ *
+ * Read more about collection references in the
+ * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/collection-reference documentation}.
+ * @typeParam T The type of the document data.
+ */
+export declare class CollectionReference<T extends DocumentData> {
+    private readonly collectionName;
+    private integrationId;
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly querySubscriptionManager;
+    /** A string that uniquely identifies this collection reference. */
+    refId: string;
+    /**
+     * Returns a document reference for the given document id.
+     * The document id is an object that maps the primary keys of the collection (as defined in the Squid Cloud Console)
+     * to their values. There are a few exceptions:
+     * 1 - String document id is only supported for the `built_in_db` when a schema was not defined.
+     * 2 - Not all the fields in the document id are required. If a field is not provided, it will be generated on the
+     *     server once the document is created (if the integration supports it).
+     * 3 - When a document id is not provided, it will be treated as an empty object or empty string.
+     * 4 - When the document id is just a `string` and not provided (applies only for the `built_in_db`), it will be
+     *    generated on the server.
+     * 5 - If the collection in the `built_in_db` does not have a schema, the document id must be provided as a string.
+     *
+     * Examples:
+     * ```typescript
+     * // For a collection in the built_in_db that does not have a schema
+     * const docRef = collectionRef.doc('my-doc-id');
+     * const docRef = collectionRef.doc({id: my-doc-id'});
+     *
+     * // For a collection with a single primary key field called "id"
+     * const docRef = collectionRef.doc({id: 'my-doc-id'});
+     *
+     * // For a collection with a composite primary key
+     * const docRef = collectionRef.doc({id1: 'my-doc-id1', id2: 'my-doc-id2'});
+     * const docRef = collectionRef.doc({id1: 'my-doc-id1'}); // id2 will be generated on the server if the integration
+     * supports it
+     *
+     * // For a collection from the `built_in_db` without a defined schema when an id is not provided
+     *  const docRef = collectionRef.doc(); // The id will be generated on the server
+     * ```
+     *
+     * @param docId The document id as an object for the different fields in the primary key or a string.
+     * @returns A document reference for the given document id.
+     */
+    doc(docId?: DocId | DocIdObj): DocumentReference<T>;
+    /**
+     * Creates a `QueryBuilder` that can be used to query the collection.
+     *
+     * @returns A `QueryBuilder` that can be used to query the collection.
+     */
+    query(): QueryBuilder<T>;
+    /**
+     * Creates a `JoinQueryBuilder` that can be used to query the collection
+     * Note that when using a join query, you have to provide an alias for the query and for every other query
+     * participating in the join.
+     *
+     * @param alias The alias for the query.
+     * @returns A `JoinQueryBuilder` that can be used to query the collection and joins with other queries.
+     */
+    joinQuery<A extends Alias>(alias: A): JoinQueryBuilder<Record<A, []>, Record<A, T>, A, A>;
+    /**
+     * Performs `or` on a list of queries. All the queries need to be on the same collection.
+     * The result will be a merge of all the queries sorted by the same sort condition of the first query.
+     * Duplicate items will be removed.
+     * @param builders The list of query builders to merge. (A query builder can be returned from the {@link query}
+     *   method).
+     * @returns A query builder that can be used to perform the `or` operation.
+     */
+    or(...builders: QueryBuilder<T>[]): SnapshotEmitter<DocumentReference<T>>;
+}

package/dist/typescript-client/src/collection-reference.factory.d.ts

@@ -1,13 +1,13 @@
-import { CollectionName, DocumentData, IntegrationId } from '@squidcloud/common';
-import { CollectionReference } from './collection-reference';
-import { DocumentReferenceFactory } from './document-reference.factory';
-import { QueryBuilderFactory } from './query/query-builder.factory';
-import { QuerySubscriptionManager } from './query/query-subscription.manager';
-export declare class CollectionReferenceFactory {
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly querySubscriptionManager;
-    private readonly collections;
-    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, querySubscriptionManager: QuerySubscriptionManager);
-    get<T extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
-}
+import { CollectionName, DocumentData, IntegrationId } from '@squidcloud/common';
+import { CollectionReference } from './collection-reference';
+import { DocumentReferenceFactory } from './document-reference.factory';
+import { QueryBuilderFactory } from './query/query-builder.factory';
+import { QuerySubscriptionManager } from './query/query-subscription.manager';
+export declare class CollectionReferenceFactory {
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly querySubscriptionManager;
+    private readonly collections;
+    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, querySubscriptionManager: QuerySubscriptionManager);
+    get<T extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
+}

package/dist/typescript-client/src/connection-details.d.ts

@@ -1,23 +1,23 @@
-import { ClientId } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-/**
- * Provides information about the connection to the Squid Server.
- */
-export declare class ConnectionDetails {
-    private readonly clientIdService;
-    private readonly socketManager;
-    private isConnected;
-    /** Whether the Squid Client SDK is currently connected to the Squid Server. */
-    get connected(): boolean;
-    /**
-     * A unique client ID that is assigned to the client. This client ID is also available to the different backend
-     * function in the context object.
-     * Note: The client ID may change after a long disconnect.
-     */
-    get clientId(): ClientId;
-    /**
-     * Returns an observable that emits true when the client is connected to the server and false when the client is
-     * disconnected from the server.
-     */
-    observeConnected(): Observable<boolean>;
-}
+import { ClientId } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+/**
+ * Provides information about the connection to the Squid Server.
+ */
+export declare class ConnectionDetails {
+    private readonly clientIdService;
+    private readonly socketManager;
+    private isConnected;
+    /** Whether the Squid Client SDK is currently connected to the Squid Server. */
+    get connected(): boolean;
+    /**
+     * A unique client ID that is assigned to the client. This client ID is also available to the different backend
+     * function in the context object.
+     * Note: The client ID may change after a long disconnect.
+     */
+    get clientId(): ClientId;
+    /**
+     * Returns an observable that emits true when the client is connected to the server and false when the client is
+     * disconnected from the server.
+     */
+    observeConnected(): Observable<boolean>;
+}

package/dist/typescript-client/src/data.manager.d.ts

@@ -1,173 +1,173 @@
-import { DocTimestamp, LockManager, Mutation, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { QuerySender } from './query/query-sender';
-import { DestructManager } from './destruct.manager';
-import DocumentIdentityService from './document-identity.service';
-import { DocumentStore } from './document-store';
-import { MutationSender } from './mutation/mutation-sender';
-import { QueryBuilderFactory } from './query/query-builder.factory';
-import { QuerySubscriptionManager } from './query/query-subscription.manager';
-import { SocketManager } from './socket.manager';
-import { TransactionId } from './types';
-export interface DocTimestampMetadata {
-    timestamp: DocTimestamp;
-    expireTimestamp?: number;
-}
-export declare class DataManager {
-    private readonly documentStore;
-    private readonly mutationSender;
-    private readonly socketManager;
-    private readonly querySubscriptionManager;
-    private readonly queryBuilderFactory;
-    private readonly lockManager;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private readonly querySender;
-    private readonly docIdToLocalTimestamp;
-    private currentTransactionId;
-    /**
-     * During a batch, any update to a document that may trigger an update to a query is collected here and once the batch
-     * ends, the relevant subscribes to these queries will be updated.
-     */
-    private readonly batchClientRequestIds;
-    /**
-     * In this map we save timestamps for documents that are available locally or recently deleted but need to remain
-     * here so if a mutation comes from the server we know whether to apply it or not based on the timestamp. For
-     * example, if a document is removed locally and immediately after, an update is received from the server - In that
-     * case, it may be the update pre-dates the data that was available locally a second ago. For that reason, the
-     * timestamp needs to be kept and even for removed documents it will be kept for ~20 seconds more.
-     *
-     * Eventually, this map is used as a gatekeeper for preventing old versions of a document (based on timestamp) to
-     * appear on the client.
-     */
-    private readonly docIdToServerTimestamp;
-    /**
-     * In the case of a local change (outgoing change) without a server timestamp, an incoming server update cannot be
-     * applied and needs to be queued until the local state allows it. In this case the incoming update will be queued in
-     * this map. Any future incoming server update to the same document will override the previous update in case it has
-     * a later timestamp.
-     */
-    private readonly pendingIncomingUpdates;
-    /**
-     * A mutation sent to the server will be stored in this map until it receives a timestamp from the server. These
-     * mutations were already applied locally and were sent to the server or about to be sent if sentToServer=false
-     * (or are queued in the MutationSender due to a lock). The existence of these pending mutations indicates the data
-     * manager to:
-     * 1 - Not apply any incoming server mutation while there are outgoing mutations without a timestamp
-     * 2 - Not delete the local document even if there are no queries related to this document - there is a chance
-     *     that there will be a future query that will need this document and the query needs to return the local version
-     *     of the document.
-     * 3 - Even when all outgoing mutations have a timestamp, it may be that there is a pending query in flight that will
-     *     need to return the document. In this case, the local document may be different from the server. Hence, it
-     *     cannot accept the server change and will wait for another update from the server. For this purpose, timestamp
-     *     will be stored in docsToTimestamp for ~20 more seconds.
-     *
-     * Note: Only one entry per squidDocId can be with sentToServer=false. This is true since all updates to the same doc
-     *       in the same batch are appended (and reduced) to the same outgoing mutation object.
-     */
-    private readonly pendingOutgoingMutations;
-    private readonly pendingOutgoingMutationsChanged;
-    /**
-     * A subject for whether there are outgoing mutations. If there are outgoing mutations, any incoming update from the
-     * server will be delayed until all the outgoing mutations will be acknowledged by the server.
-     * This mechanism is needed to avoid this case:
-     *
-     * collection.docRef('a').delete();
-     * collection.snapshots().subscribe((res) => {
-     *   // The result here may include doc with id='a' since the delete mutation was not acknowledged.
-     * });
-     *
-     * If we wait for the acknowledgment message, we will have a server timestamp and will be able to ignore the incoming
-     * result for document with id='a'.
-     */
-    private readonly outgoingMutationsEmpty;
-    /**
-     * When applying an outgoing mutation, there may be a short time that the mutation is not yet inserted into the
-     * pending outgoing mutations map. In this case, we mark the document id as known to be dirty and remove it from the
-     * set once the pending outgoing mutations map is updated.
-     */
-    private readonly knownDirtyDocs;
-    private readonly failedDocsToResync;
-    private readonly refreshDocIdToTimestamp;
-    private deleteExpiredTimestampsInterval;
-    private handleIncomingMessagesForTests;
-    constructor(documentStore: DocumentStore, mutationSender: MutationSender, socketManager: SocketManager, querySubscriptionManager: QuerySubscriptionManager, queryBuilderFactory: QueryBuilderFactory, lockManager: LockManager, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
-    getProperties(squidDocId: SquidDocId): SquidDocument | undefined;
-    /** Whether a document has changes that are out of sync with the server. */
-    isDirty(squidDocId: SquidDocId): boolean;
-    /**
-     * Runs the provided function without sending mutations to the server while collecting the updates to the different
-     * queries. Local updates will still be applied. Once the batch finishes, all the updates will be sent to the server
-     * and the different queries will be notified. runInTransaction may be invoked inside another runInTransaction, only
-     * the top level batch will trigger updates to the server.
-     */
-    runInTransaction(fn: (transactionId: TransactionId) => Promise<void>, transactionId?: TransactionId): Promise<void>;
-    /** Applies a mutation done from the client (from DocumentReference) and sends it to the server. */
-    applyOutgoingMutation(mutation: Mutation, transactionId: TransactionId | undefined): Promise<void>;
-    /** Same as runInTransaction with the exception that the passed function runs synchronously. */
-    private runInTransactionSync;
-    /** Remove properties from the document record that should not be sent to the server. */
-    private removeInternalProperties;
-    /** Listens and handles mutations and snapshots notifications from the socketManager. */
-    private handleNotifications;
-    private handleIncomingMutations;
-    private handleIncomingQuerySnapshots;
-    /**
-     * Returns a boolean for whether some updates were ignored because the client knows of a later timestamp for those
-     * documents.
-     */
-    private applyIncomingUpdates;
-    private maybeApplyIncomingUpdate;
-    private destruct;
-    private stopDeleteExpiredTimestampsJob;
-    /**
-     * Removes entries from the docToTimestamp map for all the documents that are no longer relevant for this client.
-     * If a document is currently tracked, we forget it.
-     * Cases a document is considered not relevant anymore:
-     * 1 - There are no outgoing or incoming updates for this document AND:
-     *   a - The document was deleted on the server and this client already received a notification about it OR
-     *   b - The document no longer has a query that will keep it up-to-date
-     */
-    private startDeleteExpiredTimestampsJob;
-    /**
-     * Whether the document is tracked by any pending mutations or ongoing queries.
-     */
-    isTracked(squidDocId: string): boolean;
-    /**
-     * Whether a document exists locally, but is no longer tracked by any mutations or queries. This is often the case
-     * for in-memory DocumentReferences that are not part of any query.
-     */
-    isForgotten(squidDocId: SquidDocId): boolean;
-    /**
-     * Whether a document only exists locally. This means that the document has never by sent to or received from the
-     * server.
-     */
-    isLocalOnly(squidDocId: SquidDocId): boolean;
-    /**
-     * Whether the document has even been acknowledged by the server. Acknowledgements occur when an incoming query or
-     * mutation is received, and when an outgoing mutation is acknowledged.
-     */
-    hasBeenAcknowledged(squidDocId: SquidDocId): boolean;
-    /**
-     * Updates the document with the new properties, returns true if an update was done or false in case the doc did not
-     * change.
-     */
-    private updateDocumentFromSnapshot;
-    private finishTransaction;
-    private sendAllUnsentOutgoingMutations;
-    private sendMutationsForIntegration;
-    private removeOutgoingMutation;
-    private resyncFailedUpdates;
-    private refreshUpdatedDocuments;
-    private groupOutgoingMutationsByIntegrationId;
-    /**
-     * Handles the case that due to some change (an incoming or outgoing change to a document), a document becomes orphan.
-     * That is, there are no ongoing queries that will keep it up-to-date.
-     * An orphan document should not stay locally since it may be stale after some time.
-     */
-    private handleOrphanDocs;
-    private acknowledgeDocument;
-    private setExpiration;
-    private forgetDocument;
-    private migrateDocIds;
-    private hasPendingSentMutations;
-}
+import { DocTimestamp, LockManager, Mutation, SquidDocId, SquidDocument } from '@squidcloud/common';
+import { QuerySender } from './query/query-sender';
+import { DestructManager } from './destruct.manager';
+import DocumentIdentityService from './document-identity.service';
+import { DocumentStore } from './document-store';
+import { MutationSender } from './mutation/mutation-sender';
+import { QueryBuilderFactory } from './query/query-builder.factory';
+import { QuerySubscriptionManager } from './query/query-subscription.manager';
+import { SocketManager } from './socket.manager';
+import { TransactionId } from './types';
+export interface DocTimestampMetadata {
+    timestamp: DocTimestamp;
+    expireTimestamp?: number;
+}
+export declare class DataManager {
+    private readonly documentStore;
+    private readonly mutationSender;
+    private readonly socketManager;
+    private readonly querySubscriptionManager;
+    private readonly queryBuilderFactory;
+    private readonly lockManager;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    private readonly querySender;
+    private readonly docIdToLocalTimestamp;
+    private currentTransactionId;
+    /**
+     * During a batch, any update to a document that may trigger an update to a query is collected here and once the batch
+     * ends, the relevant subscribes to these queries will be updated.
+     */
+    private readonly batchClientRequestIds;
+    /**
+     * In this map we save timestamps for documents that are available locally or recently deleted but need to remain
+     * here so if a mutation comes from the server we know whether to apply it or not based on the timestamp. For
+     * example, if a document is removed locally and immediately after, an update is received from the server - In that
+     * case, it may be the update pre-dates the data that was available locally a second ago. For that reason, the
+     * timestamp needs to be kept and even for removed documents it will be kept for ~20 seconds more.
+     *
+     * Eventually, this map is used as a gatekeeper for preventing old versions of a document (based on timestamp) to
+     * appear on the client.
+     */
+    private readonly docIdToServerTimestamp;
+    /**
+     * In the case of a local change (outgoing change) without a server timestamp, an incoming server update cannot be
+     * applied and needs to be queued until the local state allows it. In this case the incoming update will be queued in
+     * this map. Any future incoming server update to the same document will override the previous update in case it has
+     * a later timestamp.
+     */
+    private readonly pendingIncomingUpdates;
+    /**
+     * A mutation sent to the server will be stored in this map until it receives a timestamp from the server. These
+     * mutations were already applied locally and were sent to the server or about to be sent if sentToServer=false
+     * (or are queued in the MutationSender due to a lock). The existence of these pending mutations indicates the data
+     * manager to:
+     * 1 - Not apply any incoming server mutation while there are outgoing mutations without a timestamp
+     * 2 - Not delete the local document even if there are no queries related to this document - there is a chance
+     *     that there will be a future query that will need this document and the query needs to return the local version
+     *     of the document.
+     * 3 - Even when all outgoing mutations have a timestamp, it may be that there is a pending query in flight that will
+     *     need to return the document. In this case, the local document may be different from the server. Hence, it
+     *     cannot accept the server change and will wait for another update from the server. For this purpose, timestamp
+     *     will be stored in docsToTimestamp for ~20 more seconds.
+     *
+     * Note: Only one entry per squidDocId can be with sentToServer=false. This is true since all updates to the same doc
+     *       in the same batch are appended (and reduced) to the same outgoing mutation object.
+     */
+    private readonly pendingOutgoingMutations;
+    private readonly pendingOutgoingMutationsChanged;
+    /**
+     * A subject for whether there are outgoing mutations. If there are outgoing mutations, any incoming update from the
+     * server will be delayed until all the outgoing mutations will be acknowledged by the server.
+     * This mechanism is needed to avoid this case:
+     *
+     * collection.docRef('a').delete();
+     * collection.snapshots().subscribe((res) => {
+     *   // The result here may include doc with id='a' since the delete mutation was not acknowledged.
+     * });
+     *
+     * If we wait for the acknowledgment message, we will have a server timestamp and will be able to ignore the incoming
+     * result for document with id='a'.
+     */
+    private readonly outgoingMutationsEmpty;
+    /**
+     * When applying an outgoing mutation, there may be a short time that the mutation is not yet inserted into the
+     * pending outgoing mutations map. In this case, we mark the document id as known to be dirty and remove it from the
+     * set once the pending outgoing mutations map is updated.
+     */
+    private readonly knownDirtyDocs;
+    private readonly failedDocsToResync;
+    private readonly refreshDocIdToTimestamp;
+    private deleteExpiredTimestampsInterval;
+    private handleIncomingMessagesForTests;
+    constructor(documentStore: DocumentStore, mutationSender: MutationSender, socketManager: SocketManager, querySubscriptionManager: QuerySubscriptionManager, queryBuilderFactory: QueryBuilderFactory, lockManager: LockManager, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
+    getProperties(squidDocId: SquidDocId): SquidDocument | undefined;
+    /** Whether a document has changes that are out of sync with the server. */
+    isDirty(squidDocId: SquidDocId): boolean;
+    /**
+     * Runs the provided function without sending mutations to the server while collecting the updates to the different
+     * queries. Local updates will still be applied. Once the batch finishes, all the updates will be sent to the server
+     * and the different queries will be notified. runInTransaction may be invoked inside another runInTransaction, only
+     * the top level batch will trigger updates to the server.
+     */
+    runInTransaction(fn: (transactionId: TransactionId) => Promise<void>, transactionId?: TransactionId): Promise<void>;
+    /** Applies a mutation done from the client (from DocumentReference) and sends it to the server. */
+    applyOutgoingMutation(mutation: Mutation, transactionId: TransactionId | undefined): Promise<void>;
+    /** Same as runInTransaction with the exception that the passed function runs synchronously. */
+    private runInTransactionSync;
+    /** Remove properties from the document record that should not be sent to the server. */
+    private removeInternalProperties;
+    /** Listens and handles mutations and snapshots notifications from the socketManager. */
+    private handleNotifications;
+    private handleIncomingMutations;
+    private handleIncomingQuerySnapshots;
+    /**
+     * Returns a boolean for whether some updates were ignored because the client knows of a later timestamp for those
+     * documents.
+     */
+    private applyIncomingUpdates;
+    private maybeApplyIncomingUpdate;
+    private destruct;
+    private stopDeleteExpiredTimestampsJob;
+    /**
+     * Removes entries from the docToTimestamp map for all the documents that are no longer relevant for this client.
+     * If a document is currently tracked, we forget it.
+     * Cases a document is considered not relevant anymore:
+     * 1 - There are no outgoing or incoming updates for this document AND:
+     *   a - The document was deleted on the server and this client already received a notification about it OR
+     *   b - The document no longer has a query that will keep it up-to-date
+     */
+    private startDeleteExpiredTimestampsJob;
+    /**
+     * Whether the document is tracked by any pending mutations or ongoing queries.
+     */
+    isTracked(squidDocId: string): boolean;
+    /**
+     * Whether a document exists locally, but is no longer tracked by any mutations or queries. This is often the case
+     * for in-memory DocumentReferences that are not part of any query.
+     */
+    isForgotten(squidDocId: SquidDocId): boolean;
+    /**
+     * Whether a document only exists locally. This means that the document has never by sent to or received from the
+     * server.
+     */
+    isLocalOnly(squidDocId: SquidDocId): boolean;
+    /**
+     * Whether the document has even been acknowledged by the server. Acknowledgements occur when an incoming query or
+     * mutation is received, and when an outgoing mutation is acknowledged.
+     */
+    hasBeenAcknowledged(squidDocId: SquidDocId): boolean;
+    /**
+     * Updates the document with the new properties, returns true if an update was done or false in case the doc did not
+     * change.
+     */
+    private updateDocumentFromSnapshot;
+    private finishTransaction;
+    private sendAllUnsentOutgoingMutations;
+    private sendMutationsForIntegration;
+    private removeOutgoingMutation;
+    private resyncFailedUpdates;
+    private refreshUpdatedDocuments;
+    private groupOutgoingMutationsByIntegrationId;
+    /**
+     * Handles the case that due to some change (an incoming or outgoing change to a document), a document becomes orphan.
+     * That is, there are no ongoing queries that will keep it up-to-date.
+     * An orphan document should not stay locally since it may be stale after some time.
+     */
+    private handleOrphanDocs;
+    private acknowledgeDocument;
+    private setExpiration;
+    private forgetDocument;
+    private migrateDocIds;
+    private hasPendingSentMutations;
+}

package/dist/typescript-client/src/destruct.manager.d.ts

@@ -1,12 +1,12 @@
-import { Observable } from 'rxjs';
-export type DestructorFn = () => Promise<void> | void;
-export declare class DestructManager {
-    private readonly predestructors;
-    private readonly destructors;
-    private readonly isDestructedSubject;
-    get isDestructing(): boolean;
-    observeIsDestructing(): Observable<void>;
-    onPreDestruct(fn: DestructorFn): void;
-    onDestruct(fn: DestructorFn): void;
-    destruct(): Promise<void>;
-}
+import { Observable } from 'rxjs';
+export type DestructorFn = () => Promise<void> | void;
+export declare class DestructManager {
+    private readonly predestructors;
+    private readonly destructors;
+    private readonly isDestructedSubject;
+    get isDestructing(): boolean;
+    observeIsDestructing(): Observable<void>;
+    onPreDestruct(fn: DestructorFn): void;
+    onDestruct(fn: DestructorFn): void;
+    destruct(): Promise<void>;
+}