@squidcloud/client 1.0.145 → 1.0.146-beta

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

@@ -1,77 +1,228 @@
-import { BaseQueryBuilder, DocumentData, FieldName, FieldSort, HasDereference, Operator, Pagination, PaginationOptions, PrimitiveFieldType, SerializedSimpleQuery, SimpleCondition, 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 localQueryManager;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly documentIdentityService;
-    private forceFetchFromServer;
-    /** @inheritDoc */
-    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    /** @inheritDoc */
-    limit(limit: number): this;
-    getLimit(): number;
-    limitBy(limit: number, ...fields: FieldName[]): 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
-     */
-    peek(): Array<DocumentReference<DocumentType>>;
-    /**
-     * @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>;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): QueryBuilder<DocumentType>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): QueryBuilder<DocumentType>;
-    flipSortOrder(): QueryBuilder<DocumentType>;
-    serialize(): SerializedSimpleQuery;
-    extractData(data: DocumentReference<DocumentType>): DocumentType;
-    paginate(options?: Partial<PaginationOptions>): Pagination<DocumentReference<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>);
-}
+import { Observable } from 'rxjs';
+import { DocumentReference } from '../document-reference';
+import { DocumentData, FieldName, FieldSort, Operator, PrimitiveFieldType, Query, SerializedSimpleQuery, SimpleCondition } from '../public-types';
+import { Pagination, PaginationOptions } from './pagination';
+import { SnapshotEmitter } from './snapshot-emitter';
+/**
+ * Interface used solely for inheritDoc
+ * @category Database
+ */
+export interface HasDereference {
+    /**
+     * Dereferences the document references in the result of this query. For example, collection.query().snapshot()
+     * returns an array of DocumentReference objects, but collection.query().dereference().snapshot() returns an array of
+     * the actual document data.
+     */
+    dereference(): any;
+}
+/**
+ *  Query builder base class.
+ *  @category Database
+ */
+export declare abstract class BaseQueryBuilder<MyDocType extends DocumentData> {
+    /**
+     * A shortcut for `where(fieldName, '==', value)`
+     *
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    eq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for `where(fieldName, '!=', value)`
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    neq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for `where(fieldName, 'in', value)`
+     * @param fieldName The name of the field to query.
+     * @param value An array of values to compare against.
+     * @returns The query builder.
+     */
+    in(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
+    /**
+     * A shortcut for `where(fieldName, 'not in', value)`
+     * @param fieldName The name of the field to query.
+     * @param value An array of values to compare against.
+     * @returns The query builder.
+     */
+    nin(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
+    /**
+     * A shortcut for `where(fieldName, '>', value)`
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    gt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for `where(fieldName, '>=', value)`
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    gte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for `where(fieldName, '<', value)`
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    lt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for `where(fieldName, '<=', value)`
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    lte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for `where(fieldName, 'like', pattern).`
+     *
+     * @param fieldName The name of the field to query.
+     * @param pattern The pattern to compare against. '%' matches 0 or more characters. '_' matches exactly one
+     *   character. '\' can be used to escape '%', '_'. or another '\'. Note that any '\' that is not followed by '%',
+     *   '_', or '\' is invalid.
+     * @param caseSensitive Whether to use case-sensitive comparison. Defaults to true.
+     * @returns The query builder.
+     */
+    like(fieldName: (keyof MyDocType & FieldName) | string, pattern: string, caseSensitive?: boolean): this;
+    /**
+     * A shortcut for `where(fieldName, 'not like', pattern).`
+     *
+     * @param fieldName The name of the field to query.
+     * @param pattern The pattern to compare against. '%' matches 0 or more characters. '_' matches exactly one
+     *   character. '\' can be used to escape '%', '_'. or another '\'. Note that any '\' that is not followed by '%',
+     *   '_', or '\' is invalid.
+     * @param caseSensitive Whether to use case-sensitive comparison. Defaults to true.
+     * @returns The query builder.
+     */
+    notLike(fieldName: (keyof MyDocType & FieldName) | string, pattern: string, caseSensitive?: boolean): this;
+    /**
+     * Adds a condition to the query to check if the specified field includes any of the given values.
+     *
+     * @param fieldName The name of the field to query.
+     * @param values The values to check for inclusion in the field array.
+     * @returns The query builder.
+     */
+    arrayIncludesSome(fieldName: (keyof MyDocType & FieldName) | string, values: Array<PrimitiveFieldType>): this;
+    /**
+     * Adds a condition to the query to check if the specified field includes all the given values.
+     *
+     * @param fieldName The name of the field to query.
+     * @param values The values to check for inclusion in the field array.
+     * @returns The query builder.
+     */
+    arrayIncludesAll(fieldName: (keyof MyDocType & FieldName) | string, values: Array<PrimitiveFieldType>): this;
+    /**
+     * Adds a condition to the query to check if the specified field does not include any of the given values.
+     *
+     * @param fieldName The name of the field to query.
+     * @param values The values to check for non-inclusion in the field array.
+     * @returns The query builder.
+     */
+    arrayNotIncludes(fieldName: (keyof MyDocType & FieldName) | string, values: Array<PrimitiveFieldType>): this;
+    /**
+     * 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.
+     */
+    abstract where(fieldName: (keyof MyDocType & 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 limit to set.
+     * @returns The query builder.
+     */
+    abstract 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.
+     */
+    abstract sortBy(fieldName: (keyof MyDocType & FieldName) | string, asc?: boolean): this;
+    /**
+     * Returns the query object built by this query builder.
+     */
+    abstract build(): Query;
+    private throwIfInvalidLikePattern;
+}
+/**
+ * A query builder that can be used to build a query that returns a list of documents.
+ * @category Database
+ */
+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 localQueryManager;
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly documentIdentityService;
+    private forceFetchFromServer;
+    /**
+     * A unique hash for the query. Identical queries should return the same hash
+     * value.
+     *
+     * @returns The query's hash string.
+     */
+    get hash(): string;
+    /** @inheritDoc */
+    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator, value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /** @inheritDoc */
+    limit(limit: number): this;
+    getLimit(): number;
+    limitBy(limit: number, ...fields: FieldName[]): this;
+    /** @inheritDoc */
+    sortBy(fieldName: (keyof DocumentType & FieldName) | string, asc?: boolean): this;
+    /** @inheritDoc */
+    build(): Query;
+    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
+     */
+    peek(): Array<DocumentReference<DocumentType>>;
+    /**
+     * @inheritDoc
+     */
+    snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
+    /**
+     * @inheritDoc
+     */
+    changes(): Observable<Changes<DocumentType>>;
+    /** @inheritDoc */
+    dereference(): SnapshotEmitter<DocumentType>;
+    getSortOrders(): Array<FieldSort<any>>;
+    clone(): QueryBuilder<DocumentType>;
+    addCompositeCondition(conditions: Array<SimpleCondition>): QueryBuilder<DocumentType>;
+    flipSortOrder(): QueryBuilder<DocumentType>;
+    serialize(): SerializedSimpleQuery;
+    paginate(options?: Partial<PaginationOptions>): Pagination<DocumentReference<DocumentType>>;
+    private mergeConditions;
+}
+/**
+ * Describes the changes to a query result.
+ * @category Database
+ */
+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>;
+}

package/dist/typescript-client/src/query/query-sender.d.ts

@@ -1,33 +1 @@
-import { RpcManager } from '../rpc.manager';
-import { QueryRequest, QueryResultData } from '@squidcloud/common';
-import { BehaviorSubject } from 'rxjs';
-import { DestructManager } from '../destruct.manager';
-export declare class QuerySender {
-    private readonly rpcManager;
-    private readonly destructManager;
-    /**
-     * A collection of query requests awaiting batch dispatch.
-     */
-    private readonly pendingQueryRequests;
-    /**
-     * A timeout identifier used to ensure that only the last query in rapid succession triggers the batch send process.
-     */
-    private pendingQueryBatchTimeout?;
-    /**
-     * 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>;
-    /**
-     * 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;
-    constructor(rpcManager: RpcManager, destructManager: DestructManager);
-    sendQuery(queryRequest: QueryRequest): Promise<QueryResultData>;
-    private processQueryBatch;
-    /** Will resolve once all the in-flight queries are done. */
-    waitForAllQueriesToFinish(): Promise<void>;
-    private preDestruct;
-}
+export {};

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

@@ -1,130 +1 @@
-import { Alias, ClientRequestId, JoinCondition, Query, QueryResultData, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { Observable, Subject } from 'rxjs';
-import { ClientIdService } from '../client-id.service';
-import { DestructManager } from '../destruct.manager';
-import DocumentIdentityService from '../document-identity.service';
-import { DocumentStore } from '../document-store';
-import { RpcManager } from '../rpc.manager';
-import { QuerySender } from './query-sender';
-import { OngoingQuery } from './query.types';
-export declare const FETCH_BEYOND_LIMIT = 100;
-export declare const LIMIT_UNDERFLOW_TRIGGER = 20;
-export declare class QuerySubscriptionManager {
-    private readonly rpcManager;
-    private readonly clientIdService;
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private readonly querySender;
-    /**
-     * 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 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;
-    private readonly queryResultsSubject;
-    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
-    observeQueryResults(): Observable<QueryResultData>;
-    /**
-     * 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;
-    private isValidParent;
-    /**
-     * 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 findValidParentOfOngoingQuery;
-    findValidParentOfQuery(query: Query): OngoingQuery | undefined;
-    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;
-    /** 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;
-}
+export {};

package/dist/typescript-client/src/query/query.types.d.ts

@@ -1,49 +1,16 @@
-import { Alias, ClientRequestId, JoinCondition, Query, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
-export interface OngoingQuery {
-    clientRequestId: ClientRequestId;
-    query: Query;
-    supportedQueries: Array<OngoingQuery>;
-    supportingOngoingQuery?: OngoingQuery;
-    gotInitialResponse: boolean;
-    activated: boolean;
-    joinCondition?: JoinCondition;
-    alias: Alias;
-    dataSubject: BehaviorSubject<Array<SquidDocument> | null>;
-    queryRegistered: BehaviorSubject<boolean>;
-    /**
-     * In case that this query is a parent of another query (that is, the other query is a subset of this query), this
-     * query should not be unsubscribed from the server until we registered the child query in the server.
-     */
-    unsubscribeBlockerCount: BehaviorSubject<number>;
-    subscribe: boolean;
-    /**
-     * In case of joins, and if this ongoing query is the root, this field emits all the supported observables
-     * for example A.join(B, {...some join condition...}).join(C, {...some join condition}.
-     * This field will emit [A.subject.pipe(), B.subject.pipe(), C.subject.pipe()]. Any new supported queries will be
-     * added here.
-     */
-    allObservables?: ReplaySubject<Array<Observable<DocsAndAlias>>>;
-    isEmptyForJoin: boolean;
-    done: boolean;
-    isInFlight: boolean;
-    forceFetchFromServer: boolean;
-    /**
-     * If there's a limit, we request `limit + FETCH_BEYOND_LIMIT` documents from the server.
-     * If we got that many documents, that means there may be even more. In that case, if our result set goes below
-     * `limit + LIMIT_UNDERFLOW_TRIGGER` documents (due to local or remote deletions), we need to resend the query to the
-     * server to potentially get more documents.
-     * If the number of documents is less than `limit + FETCH_BEYOND_LIMIT`, that means there are not that many documents
-     * on the server, so we don't need to resend the query regardless of how small our result size is or becomes.
-     */
-    limitUnderflowState: LimitUnderflowState;
-}
-export declare enum LimitUnderflowState {
-    UNKNOWN = 0,
-    DISABLED = 1,
-    ENABLED = 2
-}
-export interface DocsAndAlias {
-    docs: Array<SquidDocument>;
-    alias: Alias;
-}
+import { Alias, SquidDocument } from '../public-types';
+/**
+ * Represents a collection of documents associated with a specific alias
+ * in a query, typically used in joined query results.
+ * @category Database
+ */
+export interface DocsAndAlias {
+    /**
+     * An array of documents retrieved as part of the query.
+     */
+    docs: Array<SquidDocument>;
+    /**
+     * The alias associated with the documents in a joined query context.
+     */
+    alias: Alias;
+}

package/dist/typescript-client/src/query/snapshot-emitter.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { SerializedQuery } from '../../../internal-common/src/public-types/serialized-query.public-types';
+import { Pagination, PaginationOptions } from './pagination';
+/**
+ * Interface for emitting query results in a reactive manner,
+ * supporting both synchronous and asynchronous access.
+ * @category Database
+ */
+export interface SnapshotEmitter<ReturnType> {
+    /**
+     * 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 changes to the query results. Defaults to `true`.
+     * @returns An observable for the query results.
+     */
+    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
+    /**
+     * Returns the results of the query based on the data that is currently available on the client. This method is useful
+     * for synchronously accessing data that has already been fetched by another query. The method will return an empty
+     * array if data has not yet been populated.
+     *
+     * @returns An array of query results.
+     */
+    peek(): Array<ReturnType>;
+    /**
+     * Returns a pagination wrapper for this query.
+     * @param options The pagination options. Defaults to `{ subscribe: true, pageSize: 100 }`.
+     */
+    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
+    /** Serializes the active query used by the emitter. */
+    serialize(): SerializedQuery;
+}

package/dist/typescript-client/src/query-utils.d.ts

@@ -0,0 +1,18 @@
+import { DocumentData } from '../../internal-common/src/public-types/document.public-types';
+import { QueryBuilder } from './query/query-builder.factory';
+/**
+ * Result of the `visitQueryResults` function.
+ * @category Database
+ */
+export interface VisitQueryResultsStats {
+    /** Count of documents visited. */
+    count: number;
+    /** Time in millis spent in the function. */
+    time: number;
+}
+/**
+ * Reads all objects from the query in a safe way (with pagination) and calls callback() on every object.
+ * The iteration is interrupted if error is thrown.
+ * @category Database
+ */
+export declare function visitQueryResults<T extends DocumentData>(query: QueryBuilder<T>, callback: (t: T) => Promise<unknown>, pageSize?: number): Promise<VisitQueryResultsStats>;

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

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+/**
+ * Interface defining the operations available for a queue manager.
+ * Allows producing and consuming messages from a queue.
+ * @category Queue
+ */
+export interface QueueManager<T> {
+    /** Publish messages to the queue */
+    produce(messages: T[]): Promise<void>;
+    /** Consume messages from the queue */
+    consume(): Observable<T>;
+}

package/dist/typescript-client/src/rate-limiter.d.ts

@@ -1,32 +1 @@
-export declare class RateLimiter {
-    private readonly capacity;
-    private readonly seconds;
-    private tokens;
-    private lastRefillTimestamp;
-    private readonly refillRatePerMs;
-    /**
-     * Creates a new rate limiter. It limits the number of requests using two parameters:
-     * - capacity: the maximum number of tokens (actions) that can be stored at any given time
-     * - seconds: the number of seconds it takes to refill the bucket to its maximum capacity
-     *
-     * We then can calculate the refillRatePerMs: the number of tokens (actions) that are added to the bucket every
-     * millisecond
-     *
-     * Example:
-     * Say we want to allow maximum 60 requests in a period of 5 seconds. We can create a rate limiter with:
-     * - capacity: 60
-     * - seconds: 5
-     * And we will get refillRatePerMs: 60 / (5 * 1000) = 0.012
-     *
-     * To use:
-     * const rateLimiter = new RateLimiter(60, 5);
-     * await rateLimiter.consume();
-     *
-     * @param capacity
-     * @param refillRatePerMs
-     */
-    constructor(capacity: number, seconds: number);
-    consume(): Promise<void>;
-    private attemptConsume;
-    private refill;
-}
+export {};