@squidcloud/client 1.0.166 → 1.0.168

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

@@ -1,161 +0,0 @@
-import { Observable } from 'rxjs';
-import { DocumentReference } from '../document-reference';
-import { QueryBuilder } from './query-builder.factory';
-import { Alias, BaseQueryBuilder, DocumentData, FieldName, FieldSort, HasDereference, Operator, Pagination, PaginationOptions, PrimitiveFieldType, SerializedJoinQuery, SimpleCondition, SnapshotEmitter } from '../public-types';
-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 the
- * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/queries#joining-data-across-collections-and-integrations documentation}.
- */
-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;
-    getLimit(): number;
-    /**
-     * 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 ReturnType[RootAlias] & 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>, IsInner extends boolean = false>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
-        left: keyof Required<ReturnType>[LeftAlias] & FieldName;
-        right: keyof NewReturnType & FieldName;
-    }, options: {
-        leftAlias: LeftAlias;
-        isInner?: IsInner;
-    }): JoinQueryBuilder<Omit<Aliases, LeftAlias> & Record<LeftAlias, [...Aliases[LeftAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & (IsInner extends true ? Record<NewAlias, NewReturnType> : Partial<Record<NewAlias, NewReturnType>>), NewAlias, RootAlias>;
-    join<NewAlias extends string, NewReturnType extends DocumentData, IsInner extends boolean = false>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
-        left: keyof Required<ReturnType>[LatestAlias] & FieldName;
-        right: keyof NewReturnType & FieldName;
-    }, options?: {
-        isInner?: IsInner;
-    }): JoinQueryBuilder<Omit<Aliases, LatestAlias> & Record<LatestAlias, [...Aliases[LatestAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & (IsInner extends true ? Record<NewAlias, NewReturnType> : Partial<Record<NewAlias, NewReturnType>>), NewAlias, RootAlias>;
-    /** @inheritDoc */
-    snapshot(): Promise<Array<WithDocumentReferences<ReturnType>>>;
-    /** @inheritDoc */
-    snapshots(subscribe?: boolean): Observable<Array<WithDocumentReferences<ReturnType>>>;
-    /**
-     * @inheritDoc
-     */
-    peek(): Array<WithDocumentReferences<ReturnType>>;
-    /** @inheritDoc */
-    grouped(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    /** @inheritDoc */
-    dereference(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    flipSortOrder(): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    extractData(data: WithDocumentReferences<ReturnType>): Required<ReturnType>[RootAlias];
-    serialize(): SerializedJoinQuery;
-    paginate(options?: Partial<PaginationOptions>): Pagination<WithDocumentReferences<ReturnType>>;
-}
-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>>;
-    /**
-     * @inheritDoc
-     */
-    peek(): Array<ReturnType>;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    flipSortOrder(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    limit(limit: number): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    extractData(data: ReturnType): any;
-    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
-    serialize(): SerializedJoinQuery;
-    getLimit(): number;
-}
-declare class GroupedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>, HasDereference {
-    readonly joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    /** internal */
-    constructor(joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>);
-    /** @inheritDoc */
-    snapshot(): Promise<Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>>;
-    /** @inheritDoc */
-    snapshots(subscribe?: boolean): Observable<Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>>;
-    /**
-     * @inheritDoc
-     */
-    peek(): Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>;
-    /** @inheritDoc */
-    dereference(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
-    private groupData;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    flipSortOrder(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    limit(limit: number): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    getLimit(): number;
-    extractData(data: Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>): any;
-    serialize(): SerializedJoinQuery;
-    paginate(options?: Partial<PaginationOptions>): Pagination<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>;
-}
-export {};

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

@@ -1,9 +0,0 @@
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { DocumentStore } from '../document-store';
-import { QuerySubscriptionManager } from './query-subscription.manager';
-export declare class LocalQueryManager {
-    private readonly documentStore;
-    private readonly documentReferenceFactory;
-    private readonly querySubscriptionManager;
-    constructor(documentStore: DocumentStore, documentReferenceFactory: DocumentReferenceFactory, querySubscriptionManager: QuerySubscriptionManager);
-}

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

@@ -1,77 +0,0 @@
-import { Observable } from 'rxjs';
-import { DocumentReference } from '../document-reference';
-import { BaseQueryBuilder, DocumentData, FieldName, FieldSort, HasDereference, Operator, Pagination, PaginationOptions, PrimitiveFieldType, SerializedSimpleQuery, SimpleCondition, SnapshotEmitter } from '../public-types';
-/** 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>);
-}

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

@@ -1,34 +0,0 @@
-import { RpcManager } from '../rpc.manager';
-import { BehaviorSubject } from 'rxjs';
-import { DestructManager } from '../destruct.manager';
-import { QueryRequest } from '../../../internal-common/src/types/query.types';
-import { QueryResultData } from '../../../internal-common/src/types/socket.types';
-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;
-}

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

@@ -1,133 +0,0 @@
-import { Observable, Subject } from 'rxjs';
-import { RpcManager } from '../rpc.manager';
-import { QuerySender } from './query-sender';
-import { OngoingQuery } from './query.types';
-import { Alias, ClientRequestId, JoinCondition, Query, SquidDocId, SquidDocument } from '../public-types';
-import { ClientIdService } from '../client-id.service';
-import { DocumentStore } from '../document-store';
-import { DestructManager } from '../destruct.manager';
-import DocumentIdentityService from '../document-identity.service';
-import { QueryResultData } from '../../../internal-common/src/types/socket.types';
-import { QuerySubscriptionId } from '../../../internal-common/src/types/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 three 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)
-     * 3 - A new snapshot if the query is refreshed after connection has been lost.
-     *
-     * 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: unknown): 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;
-}

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

@@ -1,49 +0,0 @@
-import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
-import { Alias, ClientRequestId, JoinCondition, Query, SquidDocument } from '../public-types';
-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;
-}

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

@@ -1,7 +0,0 @@
-import { Observable } from 'rxjs';
-export interface QueueManager {
-    /** Publish messages to the queue */
-    produce(messages: string[]): Promise<void>;
-    /** Consume messages from the queue */
-    consume(): Observable<string>;
-}

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

@@ -1,32 +0,0 @@
-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;
-}

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

@@ -1,30 +0,0 @@
-import { AuthManager } from './auth.manager';
-import { ClientIdService } from './client-id.service';
-import { DestructManager } from './destruct.manager';
-import { BlobAndFilename } from './types';
-import { SupportedSquidRegion } from './public-types';
-export declare class RpcManager {
-    private readonly region;
-    private readonly appId;
-    private readonly authManager;
-    private readonly clientIdService;
-    private readonly staticHeaders;
-    private readonly onGoingRpcCounter;
-    private readonly rateLimiters;
-    constructor(region: SupportedSquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
-    private getAuthHeaders;
-    awaitAllSettled(): Promise<void>;
-    setStaticHeader(key: string, value: string): void;
-    deleteStaticHeader(key: string): void;
-    getStaticHeaders(): Record<string, string>;
-    post<T>(path: string, message: unknown, files?: Array<File | BlobAndFilename>, filesFieldName?: string): Promise<T>;
-    private tryDeserializing;
-    private getRateLimiterBucket;
-}
-export declare class RpcError extends Error {
-    readonly statusCode: number;
-    readonly statusText: string;
-    readonly headers: Headers;
-    readonly url: string;
-    constructor(statusCode: number, statusText: string, headers: Headers, url: string, message?: string);
-}

package/dist/typescript-client/src/secret.client.d.ts

@@ -1,23 +0,0 @@
-import { SetSecretRequestEntry } from '../../internal-common/src/types/secret.types';
-import { SecretEntry, SecretKey, SecretValue } from './public-types';
-import { RpcManager } from './rpc.manager';
-export declare class SecretClient {
-    private readonly rpcManager;
-    constructor(rpcManager: RpcManager);
-    get(key: SecretKey): Promise<SecretEntry | undefined>;
-    getAll(): Promise<Record<SecretKey, SecretEntry>>;
-    upsert(key: SecretKey, value: SecretValue): Promise<SecretEntry>;
-    upsertMany(entries: Array<SetSecretRequestEntry>): Promise<Array<SecretEntry>>;
-    delete(key: SecretKey): Promise<void>;
-    deleteMany(keys: Array<SecretKey>): Promise<void>;
-    get apiKeys(): ApiKeysSecretClient;
-}
-declare class ApiKeysSecretClient {
-    private readonly rpcManager;
-    constructor(rpcManager: RpcManager);
-    get(key: SecretKey): Promise<SecretEntry | undefined>;
-    getAll(): Promise<Record<SecretKey, SecretEntry>>;
-    upsert(key: SecretKey): Promise<SecretEntry>;
-    delete(key: SecretKey): Promise<void>;
-}
-export {};

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

@@ -1,44 +0,0 @@
-import { SupportedSquidRegion } from './public-types';
-import { Observable } from 'rxjs';
-import { AuthManager } from './auth.manager';
-import { ClientIdService } from './client-id.service';
-import { DestructManager } from './destruct.manager';
-import { MessageFromClient, MessageToClient } from '../../internal-common/src/types/socket.types';
-export declare class SocketManager {
-    private readonly clientIdService;
-    private readonly region;
-    private readonly appId;
-    private readonly messageNotificationWrapper;
-    private readonly destructManager;
-    private readonly authManager;
-    private readonly webSocketObserver;
-    private readonly allMessagesObserver;
-    private readonly connectionReady;
-    private readonly seenMessageIds;
-    private socket;
-    private destructSubject;
-    private lastTick;
-    /**
-     * On a client disconnecting, we wait for a bit to see if the client reconnects,
-     * if no reconnect happens within the timeout, we consider the client to be too old.
-     * This value means we wait for 5 minutes before considering the client to be too old.
-     * Note: we make this a function so that we can easily override it in tests.
-     */
-    private clientTooOldThreshold;
-    private tickInterval;
-    constructor(clientIdService: ClientIdService, region: SupportedSquidRegion, appId: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, authManager: AuthManager);
-    refreshClient(): void;
-    tick(): void;
-    observeNotifications<T extends MessageToClient>(): Observable<T>;
-    observeConnectionReady(): Observable<boolean>;
-    sendMessage(message: MessageFromClient): void;
-    private sendMessageAsync;
-    /**  Sends 'kill' message ignoring 'connectionReady' observable. */
-    private sendKillMessage;
-    private connect;
-    disconnect(): void;
-    private onConnectionReady;
-    private onMessage;
-    private setupMessageAcknowledgments;
-    private destruct;
-}