@squidcloud/client 1.0.167 → 1.0.169

package/dist/cjs/index.js

@@ -30353,6 +30353,7 @@ function map(project, thisArg) {
 
 
 class AiChatbotClient {
+    /** @internal */
     constructor(rpcManager, socketManager, integrationId) {
         this.rpcManager = rpcManager;
         this.socketManager = socketManager;
@@ -30446,6 +30447,7 @@ class AiChatbotClient {
     }
 }
 class AiChatbotProfileReference {
+    /** @internal */
     constructor(client, integrationId, profileId) {
         this.client = client;
         this.integrationId = integrationId;
@@ -30550,6 +30552,7 @@ class AiChatbotProfileReference {
     }
 }
 class AiChatbotContextReference {
+    /** @internal */
     constructor(client, integrationId, profileId, id) {
         this.client = client;
         this.integrationId = integrationId;
@@ -30625,6 +30628,7 @@ class AiChatbotContextReference {
     }
 }
 class AiChatbotInstructionReference {
+    /** @internal */
     constructor(client, integrationId, profileId, id) {
         this.client = client;
         this.integrationId = integrationId;
@@ -30764,6 +30768,7 @@ function validateFieldSort(fieldSort) {
     (0,dist.assertTruthy)(isRightType(safeFieldSort.asc, 'boolean'), 'Asc needs to be boolean');
     validateFieldName(safeFieldSort.fieldName);
 }
+/** @internal */
 function validateOpenIdProvider(openIdProvider) {
     assertTruthy(openIdProvider, 'INVALID_PROVIDER');
     validateOpenIdProviderType(openIdProvider.providerType);
@@ -30772,6 +30777,7 @@ function validateOpenIdProvider(openIdProvider) {
     assertTruthy(openIdProvider.domain, 'INVALID_DOMAIN');
     return openIdProvider;
 }
+/** @internal */
 function validateOpenIdProviderType(providerType) {
     const providerArray = ['auth0'];
     assertTruthy(providerArray.includes(providerType), 'INVALID_OPEN_ID_PROVIDER_TYPE');
@@ -48197,13 +48203,13 @@ class GraphQLClient {
 
 ;// CONCATENATED MODULE: ./src/ai-chatbot-client.factory.ts
 
+/** @internal */
 class AiChatbotClientFactory {
     constructor(rpcManager, socketManager) {
         this.rpcManager = rpcManager;
         this.socketManager = socketManager;
         this.chatbotsMap = new Map();
     }
-    /** @internal */
     getChatbot(aiIntegrationId) {
         let client = this.chatbotsMap.get(aiIntegrationId);
         if (client)
@@ -48422,6 +48428,7 @@ class ClientIdService {
 
 ;// CONCATENATED MODULE: ./src/collection-reference.factory.ts
 
+/** @internal */
 class CollectionReferenceFactory {
     constructor(documentReferenceFactory, queryBuilderFactory, querySubscriptionManager) {
         this.documentReferenceFactory = documentReferenceFactory;
@@ -48643,6 +48650,7 @@ function reduceMutations(mutations) {
 
 /** Two transactions cannot run in parallel - this mutex is used for blocking a second transaction. */
 const RUN_IN_TRANSACTION_MUTEX = 'dataManager_runInTransaction';
+/** @internal */
 class DataManager {
     constructor(documentStore, mutationSender, socketManager, querySubscriptionManager, queryBuilderFactory, lockManager, destructManager, documentIdentityService, querySender) {
         this.documentStore = documentStore;
@@ -49472,6 +49480,7 @@ class DistributedLockImpl {
 
 ;// CONCATENATED MODULE: ./src/document-identity.service.ts
 
+/** @internal */
 class DocumentIdentityService {
     constructor(documentStore, destructManager) {
         this.documentStore = documentStore;
@@ -49498,12 +49507,11 @@ class DocumentIdentityService {
 
 
 
+/** @internal */
 class DocumentReferenceFactory {
     constructor(documentIdentityService) {
         this.documentIdentityService = documentIdentityService;
-        /** @internal */
         this.documents = new Map();
-        /** @internal */
         this.documentsForCollection = new Map();
         this.documentIdentityService.observeChanges().subscribe(this.migrateDocIds.bind(this));
     }
@@ -49522,16 +49530,10 @@ class DocumentReferenceFactory {
     setDataManager(dataManager) {
         this.dataManager = dataManager;
     }
-    /**
-     * @internal
-     */
     getDocumentsForCollection(integrationId, collectionName) {
         const collectionKey = this.getCollectionKey(integrationId, collectionName);
         return (this.documentsForCollection.get(collectionKey) || []).filter(d => d.hasData);
     }
-    /**
-     * @internal
-     */
     migrateDocIds(idResolutionMap) {
         for (const [, reference] of this.documents) {
             reference.migrateDocIds(idResolutionMap);
@@ -49679,6 +49681,7 @@ class GraphQLClientFactory {
 
 
 
+/** @internal */
 class MutationSender {
     constructor(rpcManager, lockManager, querySender) {
         this.rpcManager = rpcManager;
@@ -49713,13 +49716,13 @@ class MutationSender {
 ;// CONCATENATED MODULE: ./src/query/local-query-manager.ts
 
 
+/** @internal */
 class LocalQueryManager {
     constructor(documentStore, documentReferenceFactory, querySubscriptionManager) {
         this.documentStore = documentStore;
         this.documentReferenceFactory = documentReferenceFactory;
         this.querySubscriptionManager = querySubscriptionManager;
     }
-    /** @internal */
     peek(query) {
         if (!this.querySubscriptionManager.findValidParentOfQuery(query))
             return [];
@@ -49829,6 +49832,7 @@ const arrayMergeCustomizer = (a, b) => {
 // Exported only for tests
 const FETCH_BEYOND_LIMIT = 100;
 const LIMIT_UNDERFLOW_TRIGGER = 20;
+/** @internal */
 class QuerySubscriptionManager {
     constructor(rpcManager, clientIdService, documentStore, destructManager, documentIdentityService, querySender) {
         this.rpcManager = rpcManager;
@@ -51037,6 +51041,7 @@ function createWebSocketWrapper(url, opts = {}) {
 
 
 
+/** @internal */
 class SocketManager {
     constructor(clientIdService, region, appId, messageNotificationWrapper = NOOP_FN, destructManager, authManager) {
         this.clientIdService = clientIdService;
@@ -51233,6 +51238,7 @@ class SocketManager {
 ;// CONCATENATED MODULE: ./src/query/query-sender.ts
 
 
+/** @internal */
 class QuerySender {
     constructor(rpcManager, destructManager) {
         this.rpcManager = rpcManager;
@@ -51462,6 +51468,7 @@ class AiAssistantClient {
  * through its methods.
  */
 class AiClient {
+    /** @internal */
     constructor(aiChatbotClientFactory, rpcManager) {
         this.aiChatbotClientFactory = aiChatbotClientFactory;
         this.rpcManager = rpcManager;
@@ -51556,6 +51563,7 @@ class LockManager {
 
 ;// CONCATENATED MODULE: ./src/queue.manager.ts
 
+
 /** @internal */
 class QueueManagerFactory {
     constructor(rpcManager, socketManager, destructManager) {
@@ -51595,6 +51603,7 @@ class QueueManagerFactory {
         return (_a = this.queueManagers.get(integrationId)) === null || _a === void 0 ? void 0 : _a.get(topicName);
     }
 }
+const SUBSCRIPTION_MUTEX = 'subscriptionMutex';
 /** @internal */
 class QueueManagerImpl {
     constructor(integrationId, topicName, rpcManager) {
@@ -51603,6 +51612,7 @@ class QueueManagerImpl {
         this.rpcManager = rpcManager;
         this.messagesSubject = new external_rxjs_.Subject();
         this.subscriberCount = 0;
+        this.lockManager = new LockManager();
     }
     async produce(messages) {
         await this.rpcManager.post('queue/produceMessages', {
@@ -51613,32 +51623,48 @@ class QueueManagerImpl {
     }
     consume() {
         return (0,external_rxjs_.defer)(() => {
-            // Code to run when the observable is subscribed
             this.subscriberCount++;
             if (this.subscriberCount === 1) {
-                this.rpcManager
-                    .post('queue/subscribe', {
-                    integrationId: this.integrationId,
-                    topicName: this.topicName,
-                })
-                    .catch(e => {
-                    this.messagesSubject.error(e);
-                    this.messagesSubject.complete();
-                    this.subscriberCount = 0;
-                    this.messagesSubject = new external_rxjs_.Subject();
-                });
+                void this.performSubscribe();
             }
             return this.messagesSubject.asObservable().pipe((0,external_rxjs_.finalize)(() => {
                 this.subscriberCount--;
                 if (this.subscriberCount === 0) {
-                    this.rpcManager.post('queue/unsubscribe', {
-                        integrationId: this.integrationId,
-                        topicName: this.topicName,
-                    });
+                    void this.performUnsubscribe();
                 }
             }));
         });
     }
+    async performSubscribe() {
+        await this.lockManager.lock(SUBSCRIPTION_MUTEX);
+        try {
+            await this.rpcManager.post('queue/subscribe', {
+                integrationId: this.integrationId,
+                topicName: this.topicName,
+            });
+        }
+        catch (e) {
+            this.messagesSubject.error(e);
+            this.messagesSubject.complete();
+            this.subscriberCount = 0;
+            this.messagesSubject = new external_rxjs_.Subject();
+        }
+        finally {
+            this.lockManager.release(SUBSCRIPTION_MUTEX);
+        }
+    }
+    async performUnsubscribe() {
+        await this.lockManager.lock(SUBSCRIPTION_MUTEX);
+        try {
+            await this.rpcManager.post('queue/unsubscribe', {
+                integrationId: this.integrationId,
+                topicName: this.topicName,
+            });
+        }
+        finally {
+            this.lockManager.release(SUBSCRIPTION_MUTEX);
+        }
+    }
     onMessages(payload) {
         for (const message of payload) {
             this.messagesSubject.next(message);

package/dist/internal-common/src/types/backend-run.types.d.ts

@@ -1,2 +1 @@
-import { ApplicationSecrets } from './secret.types';
-export declare function convertToRunSecrets(appSecrets: ApplicationSecrets): RunSecrets;
+export {};

package/dist/internal-common/src/types/bundle-data.types.d.ts

@@ -1,4 +1 @@
-export interface LocalBackendData {
-    applicationBundleData: ApplicationBundleData;
-    openApiSpecStr?: string;
-}
+export {};

package/dist/internal-common/src/types/socket.types.d.ts

@@ -1,7 +1 @@
-import { IntegrationId } from '../public-types/communication.public-types';
-export interface QueueMessageToClient extends BaseMessageToClient {
-    type: 'queue';
-    integrationId: IntegrationId;
-    topicName: string;
-    payload: string[];
-}
+export {};

package/dist/internal-common/src/utils/validation.d.ts

@@ -1,5 +1,4 @@
 import { HttpStatus } from '../public-types/http-status.enum';
-import { OpenIdProvider } from '../public-types/application.public-types';
 export type StatusCode = HttpStatus.BAD_REQUEST | HttpStatus.NOT_FOUND | HttpStatus.FORBIDDEN | HttpStatus.UNAUTHORIZED | HttpStatus.CONFLICT;
 export declare class ValidationError extends Error {
     readonly statusCode: StatusCode;
@@ -9,8 +8,6 @@ export declare class ValidationError extends Error {
 export declare function isValidId(id: unknown): boolean;
 export declare function validateId(id: unknown, message: string): void;
 export declare function validateFieldSort(fieldSort: unknown): void;
-export declare function validateOpenIdProvider(openIdProvider: OpenIdProvider | undefined): OpenIdProvider;
-export declare function validateOpenIdProviderType(providerType: unknown): void;
 export declare function validateMutations(mutations: unknown): void;
 export declare function validateQueryLimit(limit: unknown): void;
 /** Returns true if the value is not an empty string (undefined/null are considered empty). */

package/dist/typescript-client/src/ai-chatbot-client.d.ts

@@ -1,13 +1,10 @@
-import { AiChatbotChatOptions, AiChatbotContext, AiModelName, IntegrationId } from './public-types';
+import { AiChatbotChatOptions, AiChatbotContext, AiModelName } from './public-types';
 import { Observable } from 'rxjs';
-import { RpcManager } from './rpc.manager';
-import { SocketManager } from './socket.manager';
 export declare class AiChatbotClient {
     private readonly rpcManager;
     private readonly socketManager;
     private readonly integrationId;
     private readonly ongoingChatSequences;
-    constructor(rpcManager: RpcManager, socketManager: SocketManager, integrationId: IntegrationId);
     /**
      * Retrieves a profile reference for the provided id. A profile reference
      * can be used to create and update profiles, add instructions and context
@@ -33,7 +30,6 @@ export declare class AiChatbotProfileReference {
     private readonly client;
     private readonly integrationId;
     private readonly profileId;
-    constructor(client: AiChatbotClient, integrationId: IntegrationId, profileId: string);
     /**
      * Sends a prompt to the current profile.
      *
@@ -99,7 +95,6 @@ declare class AiChatbotContextReference {
     private readonly integrationId;
     private readonly profileId;
     private readonly id;
-    constructor(client: AiChatbotClient, integrationId: IntegrationId, profileId: string, id?: string);
     /**
      * Adds a new context entry to the chatbot profile. This will result in an error if an entry already exists with
      * the same id.
@@ -140,7 +135,6 @@ declare class AiChatbotInstructionReference {
     private readonly integrationId;
     private readonly profileId;
     private readonly id;
-    constructor(client: AiChatbotClient, integrationId: IntegrationId, profileId: string, id?: string);
     /**
      * Adds a new instruction entry to the chatbot profile. This will result in an error if an entry already exists with
      * the same id.

package/dist/typescript-client/src/ai-chatbot-client.factory.d.ts

@@ -1,8 +1 @@
-import { RpcManager } from './rpc.manager';
-import { SocketManager } from './socket.manager';
-export declare class AiChatbotClientFactory {
-    private readonly rpcManager;
-    private readonly socketManager;
-    private readonly chatbotsMap;
-    constructor(rpcManager: RpcManager, socketManager: SocketManager);
-}
+export {};

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

@@ -1,6 +1,4 @@
 import { AiChatbotClient } from './ai-chatbot-client';
-import { AiChatbotClientFactory } from './ai-chatbot-client.factory';
-import { RpcManager } from './rpc.manager';
 import { AiAssistantClient } from './ai-assistant-client';
 import { IntegrationId } from './public-types';
 export interface ExecuteAiQueryRequest {
@@ -23,7 +21,6 @@ export declare class AiClient {
     private readonly aiChatbotClientFactory;
     private readonly rpcManager;
     private readonly aiAssistantClient;
-    constructor(aiChatbotClientFactory: AiChatbotClientFactory, rpcManager: RpcManager);
     /**
      * Retrieves an AI chatbot client for a specific AI integration.
      * @param aiIntegrationId - The identifier for the AI integration.

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

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

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

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

package/dist/typescript-client/src/document-identity.service.d.ts

@@ -1,12 +1 @@
-import { Observable } from 'rxjs';
-import { DestructManager } from './destruct.manager';
-import { DocumentStore } from './document-store';
-import { IdResolutionMap } from '../../internal-common/src/types/mutation.types';
-export default class DocumentIdentityService {
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly changeNotifier;
-    constructor(documentStore: DocumentStore, destructManager: DestructManager);
-    migrate(idResolutionMap: IdResolutionMap): void;
-    observeChanges(): Observable<IdResolutionMap>;
-}
+export {};

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

@@ -1,13 +1 @@
-import { SquidDocId } from './public-types';
-import { DataManager } from './data.manager';
-import DocumentIdentityService from './document-identity.service';
-import { DocumentReference } from './document-reference';
-import { QueryBuilderFactory } from './query/query-builder.factory';
-export declare class DocumentReferenceFactory {
-    private readonly documentIdentityService;
-    private dataManager;
-    constructor(documentIdentityService: DocumentIdentityService);
-    create(squidDocId: SquidDocId, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
-    setDataManager(dataManager: DataManager): void;
-    private getCollectionKey;
-}
+export {};

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

@@ -1,12 +1 @@
-import { RpcManager } from '../rpc.manager';
-import { QuerySender } from '../query/query-sender';
-import { LockManager } from '../../../internal-common/src/utils/lock.manager';
-import { IntegrationId, Mutation } from '../public-types';
-import { MutateResponse } from '../../../internal-common/src/types/mutation.types';
-export declare class MutationSender {
-    private readonly rpcManager;
-    private readonly lockManager;
-    private readonly querySender;
-    constructor(rpcManager: RpcManager, lockManager: LockManager, querySender: QuerySender);
-    sendMutations(mutations: Array<Mutation>, integrationId: IntegrationId): Promise<MutateResponse>;
-}
+export {};

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

@@ -1,9 +1 @@
-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);
-}
+export {};

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

@@ -1,34 +1 @@
-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;
-}
+export {};

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

@@ -1,133 +1,2 @@
-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/socket.manager.d.ts

@@ -1,44 +1 @@
-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;
-}
+export {};

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

@@ -1,2 +1,6 @@
 /** A transactionId - alias for string */
 export type TransactionId = string;
+export interface BlobAndFilename {
+    blob: Blob;
+    name: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.167",
+  "version": "1.0.169",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "types": "dist/typescript-client/src/index.d.ts",
@@ -14,6 +14,8 @@
     "build:prod": "webpack --mode=production",
     "watch": "webpack --watch",
     "lint": "eslint . --ext .ts",
+    "build-and-check-public-types": "npm run prebuild && npm run build && npm run check-public-types",
+    "check-public-types": "tsc -p tsconfig.types.json",
     "test": "jest --detectOpenHandles",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",