@squidcloud/client 1.0.168 → 1.0.169

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

@@ -0,0 +1,149 @@
+import { DocumentData } from './public-types';
+import { Observable } from 'rxjs';
+import { TransactionId } from './types';
+import { DeepRecord, Paths } from '../../internal-common/src/public-types/typescript.public-types';
+/**
+ * Holds a reference to a document. A document reference is a reference to a specific record in a collection. You can
+ * use it to read or write data to the document. A document can refer to a row in a table in a relational database or a
+ * document in a NoSQL database. Additionally, a document reference can refer to a non-existent document, which you can
+ * use to create a new document.
+ *
+ * Read more about document references in the
+ * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/document-reference documentation}.
+ * @typeParam T The type of the document data.
+ */
+export declare class DocumentReference<T extends DocumentData = any> {
+    private _squidDocId;
+    private readonly dataManager;
+    private readonly queryBuilderFactory;
+    /** A string that uniquely identifies this document reference. */
+    refId: string;
+    /**
+     * Returns the document data. Throws an error if the document does not exist.
+     *
+     * @returns The document data.
+     * @throws Error if the document does not exist.
+     */
+    get data(): T;
+    /**
+     * Returns a read-only internal copy of the document data. This works similar to `this.data`, except it does not
+     * perform a defensive copy. The caller may not modify this object, on penalty of unexpected behavior.
+     *
+     * @returns The document data.
+     * @throws Error if the document does not exist.
+     */
+    get dataRef(): T;
+    /**
+     * Returns whether data has been populated for this document reference. Data
+     * will not present if a document has not been queried, does not exist, or
+     * has been deleted.
+     *
+     * @returns Whether the document has data.
+     */
+    get hasData(): boolean;
+    /**
+     * A promise that resolves with the latest data from the server or undefined if the document does not exist on the
+     * server.
+     *
+     * @returns A promise that resolves with latest data from the server or undefined if the document does not exist on
+     * the server.
+     */
+    snapshot(): Promise<T | undefined>;
+    /**
+     * Returns an observable that emits the latest data from the server or undefined if the document is deleted or does
+     * not exist on the server.
+     *
+     * @returns An observable that emits the latest data from the server or undefined if the document is deleted or does
+     * not exist on the server.
+     */
+    snapshots(): Observable<T | undefined>;
+    /**
+     * Returns the data that is currently available on the client or undefined if data has not yet been populated.
+     *
+     * @returns The data that is currently available on the client or undefined if data has not yet been populated.
+     */
+    peek(): T | undefined;
+    /**
+     * Returns whether the locally available version of the document may not be the latest version on the server.
+     *
+     * @returns Whether the locally available version of the document may not be the latest version on the server.
+     */
+    isDirty(): boolean;
+    private isTracked;
+    /**
+     * Updates the document with the given data.
+     * The `update` will be reflected optimistically locally and will be applied to the server later.
+     * If a transactionId is provided, the `update` will be applied to the server as an atomic operation together with
+     * the rest of the operations in the transaction and the `update` will not reflect locally until the transaction is
+     * completed locally.
+     *
+     * The returned promise will resolve once the `update` has been applied to the server or immediately if the `update`
+     * is part of a transaction.
+     *
+     * @param data The data to update - can be partial.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    update(data: Partial<DeepRecord<T>>, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Similar to {@link update}, but only updates the given path.
+     * @param path The path to update.
+     * @param value The value to set at the given path.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    setInPath<K extends Paths<T>>(path: K, value: DeepRecord<T>[K], transactionId?: TransactionId): Promise<void>;
+    /**
+     * Similar to `update`, but only deletes the given path.
+     * @param path The path to delete.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    deleteInPath(path: Paths<T>, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Increments the value at the given path by the given value. The value may be both positive and negative.
+     * @param path The path to the value to increment.
+     * @param value The value to increment by.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    incrementInPath(path: Paths<T>, value: number, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Decrements the value at the given path by the given value. The value may be both positive and negative.
+     * @param path The path to the value to decrement.
+     * @param value The value to decrement by.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    decrementInPath(path: Paths<T>, value: number, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Inserts the document with the given data. If the document already exists, the operation will be treated as
+     * `upsert`. The `insert` will be reflected optimistically locally and will be applied to the server later. If a
+     * transactionId is provided, the `insert` will be applied to the server as an atomic operation together with the
+     * rest
+     * of the operations in the transaction and the `insert` will not reflect locally until the transaction is completed
+     * locally.
+     *
+     * The returned promise will resolve once the `insert` has been applied to the server or immediately if the `insert`
+     * is part of a transaction.
+     *
+     * @param data The data to insert.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    insert(data: T, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Deletes the document.
+     * The `delete` will be reflected optimistically locally and will be applied to the server later.
+     * If a transactionId is provided, the `delete` will be applied to the server as an atomic operation together with
+     * the rest of the operations in the transaction and the `delete` will not reflect locally until the transaction is
+     * completed locally.
+     *
+     * The returned promise will resolve once the `delete` has been applied to the server or immediately if the `delete`
+     * is part of a transaction.
+     *
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    delete(transactionId?: TransactionId): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/typescript-client/src/document-store.d.ts

@@ -0,0 +1,14 @@
+import { FieldType, Query, SquidDocId, SquidDocument } from './public-types';
+export declare class DocumentStore {
+    private readonly squidDocIdToDoc;
+    saveDocument(squidDocId: SquidDocId, properties: SquidDocument | undefined): SquidDocument | undefined;
+    hasData(squidDocId: SquidDocId): boolean;
+    getDocument(squidDocId: SquidDocId): SquidDocument;
+    getDocumentOrUndefined(squidDocId: SquidDocId): SquidDocument | undefined;
+    compareValues(a: FieldType | undefined, b: FieldType | undefined): number;
+    compareSquidDocs(a: SquidDocument, b: SquidDocument, sortFieldNames: string[], sortOrders: ('asc' | 'desc')[]): number;
+    group(sortedDocs: SquidDocument[], sortFieldNames: string[]): SquidDocument[][];
+    sortAndLimitDocs(docIdSet: Set<SquidDocId>, query: Query): Array<SquidDocument>;
+    private removeInternalProperties;
+    migrateDocId(squidDocId: SquidDocId, newSquidDocId: SquidDocId): void;
+}

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

@@ -0,0 +1,14 @@
+import { RpcManager } from './rpc.manager';
+import { GraphQLRequest, IntegrationId, SupportedSquidRegion } from './public-types';
+/** A GraphQL client that can be used to query and mutate data. */
+export declare class GraphQLClient {
+    private readonly rpcManager;
+    private readonly region;
+    private readonly appId;
+    private readonly client;
+    constructor(rpcManager: RpcManager, integrationId: IntegrationId, region: SupportedSquidRegion, appId: string);
+    /** Executes a GraphQL query and returns a promise with the result. */
+    query<T = any>(request: GraphQLRequest): Promise<T>;
+    /** Executes a GraphQL mutation and returns a promise with the result. */
+    mutate<T = Record<string, any>>(request: GraphQLRequest): Promise<T | null | undefined>;
+}

package/dist/typescript-client/src/graphql-client.factory.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLClient } from './graphql-client';
+import { RpcManager } from './rpc.manager';
+import { IntegrationId, SupportedSquidRegion } from './public-types';
+export declare class GraphQLClientFactory {
+    private readonly rpcManager;
+    private readonly region;
+    private readonly appId;
+    private readonly clientsMap;
+    constructor(rpcManager: RpcManager, region: SupportedSquidRegion, appId: string);
+    get(integrationId: IntegrationId): GraphQLClient;
+}

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

@@ -0,0 +1,11 @@
+export * from './public-types';
+export * from './public-utils';
+export { AiChatbotProfileReference } from './ai-chatbot-client';
+export { Changes, QueryBuilder } from './query/query-builder.factory';
+export { CollectionReference } from './collection-reference';
+export { DocumentReference } from './document-reference';
+export { GraphQLClient } from './graphql-client';
+export { JoinQueryBuilder } from './query/join-query-builder.factory';
+export { Squid, SquidOptions } from './squid';
+export { TransactionId } from './types';
+export { deserializeQuery } from './query/deserializer';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import { RpcManager } from './rpc.manager';
+import { IntegrationId, NativeQueryRequest } from './public-types';
+export declare class NativeQueryManager {
+    private readonly rpcManager;
+    constructor(rpcManager: RpcManager);
+    executeNativeQuery<T>(integrationId: IntegrationId, request: NativeQueryRequest): Promise<T>;
+}

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

@@ -0,0 +1,37 @@
+export * from '../../internal-common/src/public-types/ai-assistant.public-types';
+export * from '../../internal-common/src/public-types/ai-chatbot.public-context';
+export * from '../../internal-common/src/public-types/ai-chatbot.public-types';
+export * from '../../internal-common/src/public-types/api-call.public-context';
+export * from '../../internal-common/src/public-types/application.public-types';
+export * from '../../internal-common/src/public-types/base-query-builder.public-types';
+export * from '../../internal-common/src/public-types/bundle-api.public-types';
+export * from '../../internal-common/src/public-types/bundle-data.public-types';
+export * from '../../internal-common/src/public-types/communication.public-types';
+export * from '../../internal-common/src/public-types/context.public-types';
+export * from '../../internal-common/src/public-types/distributed-lock.public-context';
+export * from '../../internal-common/src/public-types/document.public-types';
+export * from '../../internal-common/src/public-types/graphql.public-context';
+export * from '../../internal-common/src/public-types/graphql.public-types';
+export * from '../../internal-common/src/public-types/http-status.enum';
+export * from '../../internal-common/src/public-types/integration.public-types';
+export * from '../../internal-common/src/public-types/integrations/ai_chatbot.types';
+export * from '../../internal-common/src/public-types/integrations/api.types';
+export * from '../../internal-common/src/public-types/integrations/auth.types';
+export * from '../../internal-common/src/public-types/integrations/database.types';
+export * from '../../internal-common/src/public-types/integrations/observability.types';
+export * from '../../internal-common/src/public-types/integrations/queue-types';
+export * from '../../internal-common/src/public-types/integrations/schemas';
+export * from '../../internal-common/src/public-types/mutation.public-context';
+export * from '../../internal-common/src/public-types/mutation.public-types';
+export * from '../../internal-common/src/public-types/native-query.public-context';
+export * from '../../internal-common/src/public-types/native-query.public-types';
+export * from '../../internal-common/src/public-types/pagination.public-types';
+export * from '../../internal-common/src/public-types/query.public-context';
+export * from '../../internal-common/src/public-types/query.public-types';
+export * from '../../internal-common/src/public-types/regions.public-types';
+export * from '../../internal-common/src/public-types/schema.public-types';
+export * from '../../internal-common/src/public-types/secret.public-types';
+export * from '../../internal-common/src/public-types/serialized-query.public-types';
+export * from '../../internal-common/src/public-types/socket.public-types';
+export * from '../../internal-common/src/public-types/topic.public-context';
+export * from '../../internal-common/src/public-types/typescript.public-types';

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

@@ -0,0 +1 @@
+export * from '../../internal-common/src/public-utils/id-utils';

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

@@ -0,0 +1,3 @@
+import { Squid } from '../squid';
+import { SerializedQuery, SnapshotEmitter } from '../public-types';
+export declare function deserializeQuery<ReturnType = any>(squid: Squid, serializedQuery: SerializedQuery): SnapshotEmitter<ReturnType>;

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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export declare const FETCH_BEYOND_LIMIT = 100;
+export declare const LIMIT_UNDERFLOW_TRIGGER = 20;

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

@@ -0,0 +1,49 @@
+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

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

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

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