@squidcloud/client 1.0.80 → 1.0.81

package/dist/typescript-client/src/query/join-query-builder.factory.d.ts

@@ -1,72 +1,110 @@
-import { BaseQueryBuilderInterface, DocumentData, FieldName, Operator, PrimitiveFieldType } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DocumentReference } from '../document-reference';
-import { Alias } from './query.types';
-/**
- * A query builder that can participate in a join.
- * To learn more about join queries, see
- * {@link https://docs.squid.cloud/docs/client-sdk/queries#joining-data-across-collections-and-integrations}.
- */
-export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType> | undefined>> extends BaseQueryBuilderInterface<ReturnType> {
-    private readonly collectionName;
-    private readonly integrationId;
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly alias;
-    private readonly joinQueryBuilderFactory;
-    private readonly queryBuilderFactory;
-    private readonly simpleQueryBuilder;
-    private readonly joins;
-    /** Record that maps the right alias to the left condition */
-    private readonly joinConditions;
-    /**
-     * Adds a condition to the query.
-     *
-     * @param fieldName The name of the field to query
-     * @param operator The operator to use
-     * @param value The value to compare against
-     * @returns The query builder
-     */
-    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    /**
-     * Sets a limit to the number of results returned by the query. The maximum limit is 20,000 and the default is 1,000
-     * if none is provided.
-     *
-     * @param limit The maximum number of results to return
-     * @returns The query builder
-     */
-    limit(limit: number): this;
-    /**
-     * Adds a sort order to the query. You can add multiple sort orders to the query. The order in which you add them
-     * determines the order in which they are applied.
-     * @param fieldName The name of the field to sort by
-     * @param asc Whether to sort in ascending order. Defaults to true.
-     * @returns The query builder
-     */
-    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
-    /**
-     * Joins this query with another join query and return a new query builder that can be used to query the joined
-     * documents.
-     * @param queryBuilder The query builder to join with
-     * @param leftFieldName The name of the field on the left side of the join
-     * @param rightFieldName The name of the field on the right side of the join
-     * @returns A new query builder that can be used to query the joined documents
-     */
-    join<J extends DocumentData, RightAlias extends Alias, RightReturnType extends Record<RightAlias, DocumentReference<J> | undefined>>(queryBuilder: JoinQueryBuilder<J, RightAlias, RightReturnType>, leftFieldName: keyof DocumentType & FieldName, rightFieldName: keyof J & FieldName): JoinQueryBuilder<DocumentType, MyAlias, ReturnType & Partial<RightReturnType>>;
-    /**
-     * Returns a promise that resolves to the query results.
-     *
-     * @returns A promise that resolves to the query results
-     */
-    snapshot(): Promise<Array<ReturnType>>;
-    /**
-     * Returns an observable that emits the query results and updates whenever the query results change unless
-     * `subscribe=false` is provided.
-     *
-     * Important: Make sure to unsubscribe from the observable when you are done with it.
-     *
-     * @param subscribe Whether to subscribe to the query. Defaults to true.
-     * @returns An observable for the query results
-     */
-    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
-}
+import { BaseQueryBuilder, DocumentData, FieldName, HasDereference, Operator, PrimitiveFieldType, SnapshotEmitter } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { DocumentReference } from '../document-reference';
+import { QueryBuilder } from './query-builder.factory';
+import { Alias } from './query.types';
+type SimpleJoinQueryBuilder<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, LatestAlias extends Alias, RootAlias extends Alias> = Pick<JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>, 'join' | 'snapshot' | 'snapshots' | 'grouped' | 'dereference'>;
+type WithDocumentReferences<T extends Record<any, DocumentData>> = {
+    [k in keyof T]: DocumentReference<Required<T>[k]>;
+};
+type Grouped<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, RootAlias extends Alias> = Aliases[RootAlias] extends [] ? Required<ReturnType>[RootAlias] : Record<RootAlias, Required<ReturnType>[RootAlias]> & OtherGroups<Aliases, ReturnType, Aliases[RootAlias]>;
+type OtherGroups<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, ManyRootAliases extends Alias[]> = ManyRootAliases extends [infer First extends Alias, ...infer Rest extends Alias[]] ? Record<First, Array<Grouped<Aliases, ReturnType, First>>> & OtherGroups<Aliases, ReturnType, Rest> : Record<Alias, never>;
+interface HasGrouped {
+    /**
+     * Transforms this join query result to a nested data structure. For example, a join between teachers and students
+     * normally returns a result of the form:
+     *   [
+     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'John Doe'} },
+     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'Jane Smith'} },
+     *     { teacher: {name: 'Mr. EmptyClass'}, student: undefined },
+     *   ]
+     * into a result of the form:
+     *   [
+     *    { teacher: {name: 'Mr. Smith'}, students: [
+     *      { name: 'John Doe' },
+     *      { name: 'Jane Smith' },
+     *    ]},
+     *    { teacher: {name: 'Mr. EmptyClass'}, students: [] },
+     *   ]
+     */
+    grouped(): any;
+}
+/**
+ * A query builder that can participate in a join.
+ * To learn more about join queries, see
+ * {@link https://docs.squid.cloud/docs/client-sdk/queries#joining-data-across-collections-and-integrations}.
+ */
+export declare class JoinQueryBuilder<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, LatestAlias extends Alias, RootAlias extends Alias> extends BaseQueryBuilder<ReturnType> implements SnapshotEmitter<WithDocumentReferences<ReturnType>>, HasGrouped, HasDereference {
+    private readonly collectionName;
+    private readonly integrationId;
+    private readonly querySubscriptionManager;
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly latestAlias;
+    private readonly joins;
+    private readonly joinConditions;
+    private readonly queryBuilder;
+    /**
+     * Adds a condition to the query.
+     *
+     * @param fieldName The name of the field to query
+     * @param operator The operator to use
+     * @param value The value to compare against
+     * @returns The query builder
+     */
+    where(fieldName: (keyof ReturnType[LatestAlias] & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /**
+     * Sets a limit to the number of results returned by the query. The maximum limit is 20,000 and the default is 1,000
+     * if none is provided.
+     *
+     * @param limit The maximum number of results to return
+     * @returns The query builder
+     */
+    limit(limit: number): this;
+    /**
+     * Adds a sort order to the query. You can add multiple sort orders to the query. The order in which you add them
+     * determines the order in which they are applied.
+     * @param fieldName The name of the field to sort by
+     * @param asc Whether to sort in ascending order. Defaults to true.
+     * @returns The query builder
+     */
+    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
+    /**
+     * Joins this query with another join query and return a new query builder that can be used to query the joined
+     * documents.
+     * @param queryBuilder The query builder to join with
+     * @param alias TODO
+     * @param joinFields TODO
+     * @param options TODO
+     * @returns A new query builder that can be used to query the joined documents
+     */
+    join<NewAlias extends string, NewReturnType extends DocumentData, LeftAlias extends Extract<keyof ReturnType, Alias>>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
+        left: keyof Required<ReturnType>[LeftAlias] & FieldName;
+        right: keyof NewReturnType & FieldName;
+    }, options: {
+        leftAlias: LeftAlias;
+    }): SimpleJoinQueryBuilder<Omit<Aliases, LeftAlias> & Record<LeftAlias, [...Aliases[LeftAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & Partial<Record<NewAlias, NewReturnType>>, NewAlias, RootAlias>;
+    join<NewAlias extends string, NewReturnType extends DocumentData>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
+        left: keyof Required<ReturnType>[LatestAlias] & FieldName;
+        right: keyof NewReturnType & FieldName;
+    }): SimpleJoinQueryBuilder<Omit<Aliases, LatestAlias> & Record<LatestAlias, [...Aliases[LatestAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & Partial<Record<NewAlias, NewReturnType>>, NewAlias, RootAlias>;
+    /** @inheritDoc */
+    snapshot(): Promise<Array<WithDocumentReferences<ReturnType>>>;
+    /** @inheritDoc */
+    snapshots(subscribe?: boolean): Observable<Array<WithDocumentReferences<ReturnType>>>;
+    /** @inheritDoc */
+    grouped(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    dereference(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+}
+declare class DereferencedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<ReturnType>, HasGrouped {
+    private readonly joinQueryBuilder;
+    constructor(joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>);
+    /** @inheritDoc */
+    grouped(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
+    /** @inheritDoc */
+    snapshot(): Promise<Array<ReturnType>>;
+    /** @inheritDoc */
+    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
+}
+export {};

package/dist/typescript-client/src/query/query-builder.factory.d.ts

@@ -1,89 +1,64 @@
-import { CollectionName, DocumentData, FieldSort, IntegrationId, SimpleQueryBuilder, SquidDocId } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import DocumentIdentityService from '../document-identity.service';
-import { DocumentReference } from '../document-reference';
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { QuerySubscriptionManager } from './query-subscription.manager';
-export declare class QueryBuilderFactory {
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly documentIdentityService;
-    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, documentIdentityService: DocumentIdentityService);
-    getForDocument<DocumentType extends DocumentData>(squidDocId: SquidDocId): QueryBuilder<DocumentType>;
-    get<DocumentType extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): QueryBuilder<DocumentType>;
-}
-/** An interface for the different actions that can be performed on a query. */
-export interface QueryActions<DocumentType extends DocumentData> {
-    /**
-     * Returns a promise that resolves to the query results.
-     *
-     * @returns A promise that resolves to the query results.
-     */
-    snapshot(): Promise<Array<DocumentReference<DocumentType>>>;
-    /**
-     * Returns an observable that emits the query results and updates whenever the query results change unless
-     * `subscribe=false` is provided.
-     *
-     * Important: Make sure to unsubscribe from the observable when you are done with it.
-     *
-     * @param subscribe Whether to subscribe to changes to the query results. Defaults to `true`.
-     * @returns An observable for the query results.
-     */
-    snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
-    /**
-     * Similar to `snapshots` but returns an observable that emits the changes to the query results. The first result
-     * will contain only inserts.
-     *
-     * @returns An observable for the query changes.
-     */
-    changes(): Observable<Changes<DocumentType>>;
-}
-/** A query builder that can be used to build a query that returns a list of documents. */
-export declare class QueryBuilder<DocumentType extends DocumentData> extends SimpleQueryBuilder<DocumentType> implements QueryActions<DocumentType> {
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly documentIdentityService;
-    private forceFetchFromServer;
-    getSortOrder(): FieldSort<DocumentType>[];
-    /**
-     * @inheritDoc
-     */
-    snapshot(): Promise<Array<DocumentReference<DocumentType>>>;
-    /**
-     * Forces the query to return data from the server even if there is a query that already returned the requested
-     * result.
-     */
-    setForceFetchFromServer(): this;
-    /**
-     * @inheritDoc
-     */
-    snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
-    /**
-     * @inheritDoc
-     */
-    changes(): Observable<Changes<DocumentType>>;
-    /**
-     * A unique hash for the query. Identical queries should return the same hash
-     * value.
-     *
-     * @returns The query's hash string.
-     */
-    get hash(): string;
-}
-/** Describes the changes to a query result. */
-export declare class Changes<DocumentType extends DocumentData> {
-    /** The newly inserted documents to the query result */
-    readonly inserts: Array<DocumentReference<DocumentType>>;
-    /** The documents that were updated in the query result */
-    readonly updates: Array<DocumentReference<DocumentType>>;
-    /** The actual document data that was deleted from the query result */
-    readonly deletes: Array<DocumentType>;
-    constructor(
-    /** The newly inserted documents to the query result */
-    inserts: Array<DocumentReference<DocumentType>>, 
-    /** The documents that were updated in the query result */
-    updates: Array<DocumentReference<DocumentType>>, 
-    /** The actual document data that was deleted from the query result */
-    deletes: Array<DocumentType>);
-}
+import { BaseQueryBuilder, DocumentData, FieldName, FieldSort, HasDereference, Operator, PrimitiveFieldType, Query, SnapshotEmitter } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { DocumentReference } from '../document-reference';
+/** A query builder that can be used to build a query that returns a list of documents. */
+export declare class QueryBuilder<DocumentType extends DocumentData> extends BaseQueryBuilder<DocumentType> implements SnapshotEmitter<DocumentReference<DocumentType>>, HasDereference {
+    private readonly collectionName;
+    private readonly integrationId;
+    private readonly querySubscriptionManager;
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly documentIdentityService;
+    private forceFetchFromServer;
+    protected readonly query: Query<DocumentType>;
+    /** @inheritDoc */
+    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /** @inheritDoc */
+    limit(limit: number): this;
+    /** @inheritDoc */
+    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
+    private mergeConditions;
+    getSortOrder(): FieldSort<DocumentType>[];
+    /**
+     * @inheritDoc
+     */
+    snapshot(): Promise<Array<DocumentReference<DocumentType>>>;
+    /**
+     * Forces the query to return data from the server even if there is a query that already returned the requested
+     * result.
+     */
+    setForceFetchFromServer(): this;
+    /**
+     * @inheritDoc
+     */
+    snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
+    /**
+     * @inheritDoc
+     */
+    changes(): Observable<Changes<DocumentType>>;
+    /**
+     * A unique hash for the query. Identical queries should return the same hash
+     * value.
+     *
+     * @returns The query's hash string.
+     */
+    get hash(): string;
+    /** @inheritDoc */
+    dereference(): SnapshotEmitter<DocumentType>;
+}
+/** Describes the changes to a query result. */
+export declare class Changes<DocumentType extends DocumentData> {
+    /** The newly inserted documents to the query result */
+    readonly inserts: Array<DocumentReference<DocumentType>>;
+    /** The documents that were updated in the query result */
+    readonly updates: Array<DocumentReference<DocumentType>>;
+    /** The actual document data that was deleted from the query result */
+    readonly deletes: Array<DocumentType>;
+    constructor(
+    /** The newly inserted documents to the query result */
+    inserts: Array<DocumentReference<DocumentType>>, 
+    /** The documents that were updated in the query result */
+    updates: Array<DocumentReference<DocumentType>>, 
+    /** The actual document data that was deleted from the query result */
+    deletes: Array<DocumentType>);
+}

package/dist/typescript-client/src/query/query-subscription.manager.d.ts

@@ -1,135 +1,135 @@
-import { ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { DestructManager } from '../destruct.manager';
-import DocumentIdentityService from '../document-identity.service';
-import { DocumentStore } from '../document-store';
-import { RpcManager } from '../rpc.manager';
-import { Alias, JoinCondition } from './query.types';
-import { ClientIdService } from '../client-id.service';
-export declare class QuerySubscriptionManager {
-    private readonly rpcManager;
-    private readonly clientIdService;
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    /**
-     * As long as there are mutations in flight we do not want to send queries because it causes race conditions,
-     * preventing parallel queries and mutations simplifies the mental model.
-     */
-    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
-    /**
-     * An observable used by the data manager, the query subscription manager (this class) identifies when a document no
-     * longer has queries that it is part of their result, such document is considered orphan. The data manager will mark
-     * as orphan.
-     */
-    onOrphanDocuments: Subject<string[]>;
-    /** All the currently running queries with their full state. */
-    private readonly ongoingQueries;
-    /**
-     * The number of queries that are currently in-flight (about to be sent to the server or sent but did not get a
-     * response yet). This is used by the data manager to prevent it from sending mutations while there are in-flight
-     * queries.
-     */
-    private readonly inflightQueriesCount;
-    /**
-     * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
-     * This relation is used for determining whether a document can be safely removed.
-     */
-    private readonly clientRequestIdToLocalDocuments;
-    private readonly localDocumentToClientRequestIds;
-    /**
-     * A data structure for mapping queries to allow reverse queries search (given a document, find all the matching
-     * queries)
-     */
-    private readonly queryMappingManager;
-    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
-    /**
-     * Returns true if the client knows about this clientRequestId. It may happen that it will return false in the case
-     * that the client unsubscribed from a query but the server sent a mutation update for this clientRequestId.
-     */
-    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
-    /**
-     * Returns the query associated with the given clientRequestId. Throws error if the clientRequestId is not known.
-     */
-    getQuery(clientRequestId: ClientRequestId): Query;
-    /**
-     * A query receives updates from two different sources:
-     * 1 - An initial snapshot from the server or from a parent query
-     * 2 - Incremental updates from the server (or from a parent query before the query is registered)
-     *
-     * If an incremental update is received before the snapshot was received, we cannot process it for this query.
-     * This boolean indicates whether the initial snapshot was received.
-     */
-    setGotInitialResult(clientRequestId: ClientRequestId): void;
-    /** Given a document, returns all the queries that should be notified with the new document properties. */
-    findQueriesForDocument(doc: SquidDocument, squidDocId: SquidDocId): Array<QuerySubscriptionId>;
-    /**
-     * Given the new document's properties, finds all the queries that should be notified with the new properties and
-     * updates the internal mappings (squidDocId --> client request Ids and, clientRequestId --> squidDocIds).
-     * Returns an array with all the previous and current client request ids (basically all the client request ids that
-     * will need to be notified due to the change of properties).
-     */
-    setClientRequestIdsForLocalDoc(squidDocId: SquidDocId, properties: SquidDocument | undefined): Array<ClientRequestId>;
-    /**
-     * Due to an error when syncing a document, all the queries that are subscribed to this document should be notified
-     * and error out.
-     */
-    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
-    /** Notifies to all the given queries (identified by their clientRequestId) with the updated query result. */
-    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
-    /**
-     * Given an ongoing query, search for candidate ongoing queries that can serve as a parent.
-     * If there is a parent query, the result of that query can be used for serving the current query.
-     * We will still register the current query on the server, but we do not need to run the query, apply security rules,
-     * etc.
-     */
-    private findValidParentQuery;
-    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean, forceFetchFromServer: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
-    /**
-     * Returns whether the given document ID has a query that has this document ID as a result.
-     * A document without a query is considered "un-tracked".
-     */
-    hasOngoingQueryForDocId(squidDocId: string): boolean;
-    /**
-     * Removes a query from the mapping and updates the orphan documents as needed.
-     */
-    private removeClientRequestIdMapping;
-    /** Will resolve once all the in-flight queries are done. */
-    waitForAllQueriesToFinish(): Promise<void>;
-    /** Register logic for cleaning up the query when it is unsubscribed. */
-    private registerQueryFinalizer;
-    /** Creates a graph of ongoing queries and returns the root of the graph. */
-    private createOngoingQueryGraph;
-    private collectAllObservables;
-    private joinResults;
-    private join;
-    private getOngoingQueriesBfs;
-    private updateOngoingQueryWithNewDataFromSupportingQuery;
-    private allOngoingQueriesGotInitialResult;
-    private completeAllSupportedQueries;
-    private predestruct;
-    unsubscribe(): void;
-    hasSubscription(clientRequestId: ClientRequestId): boolean;
-    /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
-    private sendQueryToServerOrUseParentQuery;
-    /**
-     * Uses the parent query as the source of data for the given ongoing query until the ongoing query is registered on
-     * the server. It prevents the parent query from being unsubscribed until the query is registered on the server and
-     * the first snapshot is received from the parent query.
-     * 1 - Prevents the parent query from being unsubscribed
-     * 2 - Connects the results of the parent query to the result of the current ongoing query
-     * 3 - Registers the query on the server
-     */
-    private useParentOngoingQuery;
-    /**
-     * Sends the /query request to the server. It:
-     * 1 - Waits for when it is safe to send a query to the server (no in-flight mutations)
-     * 2 - Increments the number of inflightQueriesCount to prevent parallel mutations
-     * 3 - Handles errors
-     * 4 - Marks the query as registered
-     */
-    private sendQueryToServer;
-    /** naive way to refresh queries/subscriptions when we have a new client id */
-    private refreshOngoingQueries;
-    private migrateDocIds;
-}
+import { ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { DestructManager } from '../destruct.manager';
+import DocumentIdentityService from '../document-identity.service';
+import { DocumentStore } from '../document-store';
+import { RpcManager } from '../rpc.manager';
+import { Alias, JoinCondition } from './query.types';
+import { ClientIdService } from '../client-id.service';
+export declare class QuerySubscriptionManager {
+    private readonly rpcManager;
+    private readonly clientIdService;
+    private readonly documentStore;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    /**
+     * As long as there are mutations in flight we do not want to send queries because it causes race conditions,
+     * preventing parallel queries and mutations simplifies the mental model.
+     */
+    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
+    /**
+     * An observable used by the data manager, the query subscription manager (this class) identifies when a document no
+     * longer has queries that it is part of their result, such document is considered orphan. The data manager will mark
+     * as orphan.
+     */
+    onOrphanDocuments: Subject<string[]>;
+    /** All the currently running queries with their full state. */
+    private readonly ongoingQueries;
+    /**
+     * The number of queries that are currently in-flight (about to be sent to the server or sent but did not get a
+     * response yet). This is used by the data manager to prevent it from sending mutations while there are in-flight
+     * queries.
+     */
+    private readonly inflightQueriesCount;
+    /**
+     * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
+     * This relation is used for determining whether a document can be safely removed.
+     */
+    private readonly clientRequestIdToLocalDocuments;
+    private readonly localDocumentToClientRequestIds;
+    /**
+     * A data structure for mapping queries to allow reverse queries search (given a document, find all the matching
+     * queries)
+     */
+    private readonly queryMappingManager;
+    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
+    /**
+     * Returns true if the client knows about this clientRequestId. It may happen that it will return false in the case
+     * that the client unsubscribed from a query but the server sent a mutation update for this clientRequestId.
+     */
+    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
+    /**
+     * Returns the query associated with the given clientRequestId. Throws error if the clientRequestId is not known.
+     */
+    getQuery(clientRequestId: ClientRequestId): Query;
+    /**
+     * A query receives updates from two different sources:
+     * 1 - An initial snapshot from the server or from a parent query
+     * 2 - Incremental updates from the server (or from a parent query before the query is registered)
+     *
+     * If an incremental update is received before the snapshot was received, we cannot process it for this query.
+     * This boolean indicates whether the initial snapshot was received.
+     */
+    setGotInitialResult(clientRequestId: ClientRequestId): void;
+    /** Given a document, returns all the queries that should be notified with the new document properties. */
+    findQueriesForDocument(doc: SquidDocument, squidDocId: SquidDocId): Array<QuerySubscriptionId>;
+    /**
+     * Given the new document's properties, finds all the queries that should be notified with the new properties and
+     * updates the internal mappings (squidDocId --> client request Ids and, clientRequestId --> squidDocIds).
+     * Returns an array with all the previous and current client request ids (basically all the client request ids that
+     * will need to be notified due to the change of properties).
+     */
+    setClientRequestIdsForLocalDoc(squidDocId: SquidDocId, properties: SquidDocument | undefined): Array<ClientRequestId>;
+    /**
+     * Due to an error when syncing a document, all the queries that are subscribed to this document should be notified
+     * and error out.
+     */
+    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
+    /** Notifies to all the given queries (identified by their clientRequestId) with the updated query result. */
+    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
+    /**
+     * Given an ongoing query, search for candidate ongoing queries that can serve as a parent.
+     * If there is a parent query, the result of that query can be used for serving the current query.
+     * We will still register the current query on the server, but we do not need to run the query, apply security rules,
+     * etc.
+     */
+    private findValidParentQuery;
+    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean, forceFetchFromServer: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
+    /**
+     * Returns whether the given document ID has a query that has this document ID as a result.
+     * A document without a query is considered "un-tracked".
+     */
+    hasOngoingQueryForDocId(squidDocId: string): boolean;
+    /**
+     * Removes a query from the mapping and updates the orphan documents as needed.
+     */
+    private removeClientRequestIdMapping;
+    /** Will resolve once all the in-flight queries are done. */
+    waitForAllQueriesToFinish(): Promise<void>;
+    /** Register logic for cleaning up the query when it is unsubscribed. */
+    private registerQueryFinalizer;
+    /** Creates a graph of ongoing queries and returns the root of the graph. */
+    private createOngoingQueryGraph;
+    private collectAllObservables;
+    private joinResults;
+    private join;
+    private getOngoingQueriesBfs;
+    private updateOngoingQueryWithNewDataFromSupportingQuery;
+    private allOngoingQueriesGotInitialResult;
+    private completeAllSupportedQueries;
+    private predestruct;
+    unsubscribe(): void;
+    hasSubscription(clientRequestId: ClientRequestId): boolean;
+    /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
+    private sendQueryToServerOrUseParentQuery;
+    /**
+     * Uses the parent query as the source of data for the given ongoing query until the ongoing query is registered on
+     * the server. It prevents the parent query from being unsubscribed until the query is registered on the server and
+     * the first snapshot is received from the parent query.
+     * 1 - Prevents the parent query from being unsubscribed
+     * 2 - Connects the results of the parent query to the result of the current ongoing query
+     * 3 - Registers the query on the server
+     */
+    private useParentOngoingQuery;
+    /**
+     * Sends the /query request to the server. It:
+     * 1 - Waits for when it is safe to send a query to the server (no in-flight mutations)
+     * 2 - Increments the number of inflightQueriesCount to prevent parallel mutations
+     * 3 - Handles errors
+     * 4 - Marks the query as registered
+     */
+    private sendQueryToServer;
+    /** naive way to refresh queries/subscriptions when we have a new client id */
+    private refreshOngoingQueries;
+    private migrateDocIds;
+}