@squidcloud/client 1.0.34 → 1.0.36

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

@@ -1,59 +1,59 @@
-import { ClientId, ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { DestructManager } from '../destruct.manager';
-import DocumentIdentityService from '../document-identity.service';
-import { DocumentStore } from '../document-store';
-import { RpcManager } from '../rpc.manager';
-import { Alias, JoinCondition } from './query.types';
-export declare class QuerySubscriptionManager {
-    private readonly rpcManager;
-    private readonly clientId;
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
-    onOrphanDocuments: Subject<string[]>;
-    private readonly ongoingQueries;
-    private readonly inflightQueriesCount;
-    /**
-     * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
-     * This relation is used for determining whether a document can be safely removed.
-     */
-    private readonly clientRequestIdToLocalDocuments;
-    private readonly localDocumentToClientRequestIds;
-    private readonly queryMappingManager;
-    constructor(rpcManager: RpcManager, clientId: ClientId, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
-    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
-    getQuery(clientRequestId: ClientRequestId): Query;
-    setGotResponseFromServer(clientRequestId: ClientRequestId): void;
-    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>;
-    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
-    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
-    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
-    hasOngoingQueryForDocId(squidDocId: string): boolean;
-    private removeClientRequestId;
-    waitForAllQueriesToFinish(): Promise<void>;
-    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 allOngoingQueriesGotServerResult;
-    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 sendQueryToServer;
-    private migrateDocIds;
-}
+import { ClientId, ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { DestructManager } from '../destruct.manager';
+import DocumentIdentityService from '../document-identity.service';
+import { DocumentStore } from '../document-store';
+import { RpcManager } from '../rpc.manager';
+import { Alias, JoinCondition } from './query.types';
+export declare class QuerySubscriptionManager {
+    private readonly rpcManager;
+    private readonly clientId;
+    private readonly documentStore;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
+    onOrphanDocuments: Subject<string[]>;
+    private readonly ongoingQueries;
+    private readonly inflightQueriesCount;
+    /**
+     * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
+     * This relation is used for determining whether a document can be safely removed.
+     */
+    private readonly clientRequestIdToLocalDocuments;
+    private readonly localDocumentToClientRequestIds;
+    private readonly queryMappingManager;
+    constructor(rpcManager: RpcManager, clientId: ClientId, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
+    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
+    getQuery(clientRequestId: ClientRequestId): Query;
+    setGotResponseFromServer(clientRequestId: ClientRequestId): void;
+    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>;
+    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
+    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
+    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
+    hasOngoingQueryForDocId(squidDocId: string): boolean;
+    private removeClientRequestId;
+    waitForAllQueriesToFinish(): Promise<void>;
+    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 allOngoingQueriesGotServerResult;
+    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 sendQueryToServer;
+    private migrateDocIds;
+}

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

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

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

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

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

@@ -1,14 +1,14 @@
-import { FieldName } from '@squidcloud/common';
-/**
- * An alias for a join result. This is used to disambiguate fields in the result.
- */
-export type Alias = string;
-/**
- * A join condition.
- * The join conditions defines the alias for the left side of the join and the field names to join on.
- */
-export interface JoinCondition {
-    leftAlias: Alias;
-    leftFieldName: FieldName;
-    rightFieldName: FieldName;
-}
+import { FieldName } from '@squidcloud/common';
+/**
+ * An alias for a join result. This is used to disambiguate fields in the result.
+ */
+export type Alias = string;
+/**
+ * A join condition.
+ * The join conditions defines the alias for the left side of the join and the field names to join on.
+ */
+export interface JoinCondition {
+    leftAlias: Alias;
+    leftFieldName: FieldName;
+    rightFieldName: FieldName;
+}

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

@@ -1,30 +1,30 @@
-import { ApiKey } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DestructManager } from './destruct.manager';
-import { SocketManagerInterface } from './socket.manager';
-export declare class RpcManager {
-    private readonly rpcEndpoint;
-    private readonly socketManager;
-    private readonly headers;
-    private readonly staticHeaders;
-    private readonly onGoingRpcsCounter;
-    private readonly authIdTokenSet;
-    private readonly authIdTokenObservableSubject;
-    private shouldWaitForAuth;
-    constructor(rpcEndpoint: string, socketManager: SocketManagerInterface, destructManager: DestructManager, headers?: Record<string, string>, apiKey?: ApiKey);
-    awaitAllSettled(): Promise<void>;
-    setAuthIdToken(idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>): void;
-    setStaticHeader(key: string, value: string): void;
-    deleteStaticHeader(key: string): void;
-    getEndpoint(): string;
-    getStaticHeaders(): Record<string, string>;
-    post<T>(path: string, message: any): Promise<T>;
-}
-export declare class RpcError extends Error {
-    readonly statusCode: number;
-    readonly statusText: string;
-    readonly headers: Headers;
-    readonly url: string;
-    readonly body: string;
-    constructor(statusCode: number, statusText: string, headers: Headers, url: string, body: string);
-}
+import { ApiKey } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { DestructManager } from './destruct.manager';
+import { SocketManagerInterface } from './socket.manager';
+export declare class RpcManager {
+    private readonly rpcEndpoint;
+    private readonly socketManager;
+    private readonly headers;
+    private readonly staticHeaders;
+    private readonly onGoingRpcsCounter;
+    private readonly authIdTokenSet;
+    private readonly authIdTokenObservableSubject;
+    private shouldWaitForAuth;
+    constructor(rpcEndpoint: string, socketManager: SocketManagerInterface, destructManager: DestructManager, headers?: Record<string, string>, apiKey?: ApiKey);
+    awaitAllSettled(): Promise<void>;
+    setAuthIdToken(idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>): void;
+    setStaticHeader(key: string, value: string): void;
+    deleteStaticHeader(key: string): void;
+    getEndpoint(): string;
+    getStaticHeaders(): Record<string, string>;
+    post<T>(path: string, message: any): Promise<T>;
+}
+export declare class RpcError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly url: string;
+    readonly body: string;
+    constructor(statusCode: number, statusText: string, headers: Headers, url: string, body: string);
+}

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

@@ -1,27 +1,27 @@
-import { ClientId, MessageFromClient, MessageToClient } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DestructManager } from './destruct.manager';
-export interface SocketManagerInterface {
-    observeNotifications(): Observable<MessageToClient>;
-    observeConnectionReady(): Observable<boolean>;
-    sendMessage(message: MessageFromClient): void;
-}
-export declare class SocketManager implements SocketManagerInterface {
-    private readonly clientId;
-    private readonly socketIoEndpoint;
-    private readonly messageNotificationWrapper;
-    private readonly destructManager;
-    private readonly webSocketObserver;
-    private readonly allMessagesObserver;
-    private readonly connectionReady;
-    private readonly seenMessageIds;
-    private socket;
-    private firstConnection;
-    constructor(clientId: ClientId, socketIoEndpoint: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, extraHeaders?: Record<string, string>);
-    observeNotifications(): Observable<MessageToClient>;
-    observeConnectionReady(): Observable<boolean>;
-    sendMessage(message: MessageFromClient): void;
-    private connect;
-    private setupMessageAcknowledgments;
-    private destruct;
-}
+import { ClientId, MessageFromClient, MessageToClient } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { DestructManager } from './destruct.manager';
+export interface SocketManagerInterface {
+    observeNotifications(): Observable<MessageToClient>;
+    observeConnectionReady(): Observable<boolean>;
+    sendMessage(message: MessageFromClient): void;
+}
+export declare class SocketManager implements SocketManagerInterface {
+    private readonly clientId;
+    private readonly socketIoEndpoint;
+    private readonly messageNotificationWrapper;
+    private readonly destructManager;
+    private readonly webSocketObserver;
+    private readonly allMessagesObserver;
+    private readonly connectionReady;
+    private readonly seenMessageIds;
+    private socket;
+    private firstConnection;
+    constructor(clientId: ClientId, socketIoEndpoint: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, extraHeaders?: Record<string, string>);
+    observeNotifications(): Observable<MessageToClient>;
+    observeConnectionReady(): Observable<boolean>;
+    sendMessage(message: MessageFromClient): void;
+    private connect;
+    private setupMessageAcknowledgments;
+    private destruct;
+}

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

@@ -1,173 +1,173 @@
-import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, IntegrationId, QueryName, SupportedSquidRegion } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { CollectionReference } from './collection-reference';
-import { GraphQLClient } from './graphql-client';
-import { TransactionId } from './types';
-/** The different options that can be used to initialize a Squid instance. */
-export interface SquidOptions {
-    /**
-     * A function that can be used to wrap messages coming from Squid to the application. This is useful for
-     * different frameworks that need to wrap messages in order to detect changes (like Angular).
-     * @param fn The function to wrap.
-     */
-    messageNotificationWrapper?: (fn: () => any) => any;
-    /**
-     * The application ID that is used to identify the application in Squid. The ID can be found in the Squid Cloud
-     * Console.
-     */
-    appId: AppId;
-    /**
-     * The application API key, using the API key can be used to bypass security rules and other restrictions.
-     * The API key can be found in the Squid Cloud Console.
-     */
-    apiKey?: ApiKey;
-    /**
-     * The region that the application is running in. This is used to determine the URL of the Squid Cloud API.
-     */
-    region: SupportedSquidRegion;
-    /**
-     * A list of API endpoints that can be used for overriding the default API endpoints for the different integrations.
-     * This is useful for APIs that have multiple base urls hosted in different regions.
-     */
-    apiServerUrlOverrideMapping?: Record<IntegrationId, string>;
-}
-/**
- * The main entry point to the Squid Client SDK.
- *
- * The Squid class provides a comprehensive array of functionality for accessing the different integrations, executing
- * backend functions, managing data, and more. Upon instantiating the Squid class, you will have access to all of these
- * capabilities.
- */
-export declare class Squid {
-    private readonly socketManager;
-    private readonly clientId;
-    private readonly rpcManager;
-    private readonly dataManager;
-    private readonly documentReferenceFactory;
-    private readonly documentStore;
-    private readonly lockManager;
-    private readonly querySubscriptionManager;
-    private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
-    private readonly collectionReferenceFactory;
-    private readonly backendFunctionManager;
-    private readonly namedQueryManager;
-    private readonly apiManager;
-    private readonly graphqlClientFactory;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private static readonly squidInstancesMap;
-    /**
-     * Creates a new instance of Squid with the given options.
-     *
-     * @param options The options for initializing the Squid instance.
-     */
-    constructor(options: SquidOptions);
-    /**
-     * Returns the global Squid instance with the given options, creating a new instance if one with the same options
-     * does not exist.
-     *
-     * @param options The options for initializing the Squid instance.
-     * @returns A global Squid instance with the given options.
-     */
-    static getInstance(options: SquidOptions): Squid;
-    /**
-     * Returns all the global Squid instances.
-     *
-     * @returns An array of all the global Squid instances.
-     */
-    static getInstances(): Array<Squid>;
-    /**
-     * Sets the auth id token (OpenId) that will be sent to the server and will be used for providing the `auth` object
-     * to the security rules.
-     *
-     * @param idToken The auth id token, a promise that resolves with the id token, or an observable that emits the id
-     * token. Undefined if the user is not authenticated.
-     * @returns void
-     */
-    setAuthIdToken: (idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>) => void;
-    /**
-     * Returns a reference to the collection in the provided integration.
-     *
-     * If the integrationId is not provided, the `built_in_db` integration id will be used.
-     *
-     * For more information on the CollectionReference object, please refer to the
-     * documentation at {@link https://docs.squid.cloud/docs/client-sdk/collection-reference}.
-     *
-     * @param collectionName The name of the collection.
-     * @param integrationId The id of the integration, default to `built_in_db`.
-     * @returns A reference to the collection in the provided integration.
-     * @typeParam T The type of the documents in the collection.
-     */
-    collection: <T extends DocumentData>(collectionName: CollectionName, integrationId?: IntegrationId) => CollectionReference<T>;
-    /**
-     * Runs the given callback as an atomic change. All the mutations that are executed using the provided transactionId
-     * will be atomic. Note that mutations for different integrations will not be atomic.
-     *
-     * For more information about transactions in Squid, please refer to the
-     * documentation at {@link https://docs.squid.cloud/docs/client-sdk/transactions}.
-     *
-     * @param fn The callback to run as an atomic change. The function receives a transactionId that should be used for
-     * all the mutations that should be atomic. The function should return a promise.
-     *
-     * @returns A promise that resolves when the transactions is committed on the server.
-     */
-    runInTransaction: (fn: (transactionId: TransactionId) => Promise<void>) => Promise<void>;
-    /**
-     * Executes the given backend function with the given parameters and returns a promise with the result.
-     *
-     * For more information about backend functions in Squid, please refer to the
-     * documentation at {@link https://docs.squid.cloud/docs/backend/executables}.
-     *
-     * @param functionName The name of the function to execute on the server.
-     * @param params The parameters to pass to the function.
-     * @returns A promise that resolves with the result of the function.
-     * @typeParam T The type of the result of the function.
-     */
-    executeFunction: <T = any>(functionName: string, ...params: any[]) => Promise<T>;
-    /**
-     * Executes the given named query with the given parameters and returns a promise with the result.
-     *
-     * For more information about named queries in Squid, please refer to the
-     * documentation at {@link https://docs.squid.cloud/docs/backend/named-queries}.
-     *
-     * @param integrationId The id of the integration that the named query is defined with.
-     * @param queryName The name of the named query.
-     * @param params The parameters to pass to the named query.
-     * @returns A promise that resolves with the result of the named query.
-     * @typeParam T The type of the result of the named query.
-     */
-    executeNamedQuery: <T = any>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>) => Promise<T>;
-    /**
-     * Invokes the given HTTP API (defined by the integration ID and the endpoint ID) with the given request parameters
-     * and returns a promise with the response. The structure of the request and the response is defined in the
-     * integration's schema page.
-     *
-     * For more information about API integrations in Squid, please refer to the
-     * documentation at {@link https://docs.squid.cloud/docs/integrations/httpapi}.
-     *
-     * @param integrationId The id of the integration that the API is defined with.
-     * @param endpointId The id of the endpoint in the API integration.
-     * @param request The request parameters to pass to the API.
-     * @returns A promise that resolves with the response of the API.
-     * @typeParam T The type of the response of the API.
-     */
-    callApi: <T = any>(integrationId: IntegrationId, endpointId: ApiEndpointId, request?: Record<string, any>) => Promise<T>;
-    /**
-     * Returns a GraphQL client for the given integration. The GraphQL client can be used to execute GraphQL queries and
-     * mutations. For more information about GraphQL in Squid, please refer to the documentation at
-     * {@link https://docs.squid.cloud/docs/integrations/graphql}.
-     *
-     * @param integrationId The id of the integration that the GraphQL API is defined with.
-     * @returns A GraphQL client for the given integration.
-     */
-    graphql: (integrationId: IntegrationId) => GraphQLClient;
-    /**
-     * Destructs the Squid Client. Unsubscribes from all ongoing queries or requests, and clears the local data.
-     * After invoking this method, the Squid client will not be usable.
-     *
-     * @returns A promise that resolves when the destruct process is complete.
-     */
-    destruct: () => Promise<void>;
-    private validateNotDestructed;
-}
+import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, IntegrationId, QueryName, SupportedSquidRegion } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { CollectionReference } from './collection-reference';
+import { GraphQLClient } from './graphql-client';
+import { TransactionId } from './types';
+/** The different options that can be used to initialize a Squid instance. */
+export interface SquidOptions {
+    /**
+     * A function that can be used to wrap messages coming from Squid to the application. This is useful for
+     * different frameworks that need to wrap messages in order to detect changes (like Angular).
+     * @param fn The function to wrap.
+     */
+    messageNotificationWrapper?: (fn: () => any) => any;
+    /**
+     * The application ID that is used to identify the application in Squid. The ID can be found in the Squid Cloud
+     * Console.
+     */
+    appId: AppId;
+    /**
+     * The application API key, using the API key can be used to bypass security rules and other restrictions.
+     * The API key can be found in the Squid Cloud Console.
+     */
+    apiKey?: ApiKey;
+    /**
+     * The region that the application is running in. This is used to determine the URL of the Squid Cloud API.
+     */
+    region: SupportedSquidRegion;
+    /**
+     * A list of API endpoints that can be used for overriding the default API endpoints for the different integrations.
+     * This is useful for APIs that have multiple base urls hosted in different regions.
+     */
+    apiServerUrlOverrideMapping?: Record<IntegrationId, string>;
+}
+/**
+ * The main entry point to the Squid Client SDK.
+ *
+ * The Squid class provides a comprehensive array of functionality for accessing the different integrations, executing
+ * backend functions, managing data, and more. Upon instantiating the Squid class, you will have access to all of these
+ * capabilities.
+ */
+export declare class Squid {
+    private readonly socketManager;
+    private readonly clientId;
+    private readonly rpcManager;
+    private readonly dataManager;
+    private readonly documentReferenceFactory;
+    private readonly documentStore;
+    private readonly lockManager;
+    private readonly querySubscriptionManager;
+    private readonly queryBuilderFactory;
+    private readonly joinQueryBuilderFactory;
+    private readonly collectionReferenceFactory;
+    private readonly backendFunctionManager;
+    private readonly namedQueryManager;
+    private readonly apiManager;
+    private readonly graphqlClientFactory;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    private static readonly squidInstancesMap;
+    /**
+     * Creates a new instance of Squid with the given options.
+     *
+     * @param options The options for initializing the Squid instance.
+     */
+    constructor(options: SquidOptions);
+    /**
+     * Returns the global Squid instance with the given options, creating a new instance if one with the same options
+     * does not exist.
+     *
+     * @param options The options for initializing the Squid instance.
+     * @returns A global Squid instance with the given options.
+     */
+    static getInstance(options: SquidOptions): Squid;
+    /**
+     * Returns all the global Squid instances.
+     *
+     * @returns An array of all the global Squid instances.
+     */
+    static getInstances(): Array<Squid>;
+    /**
+     * Sets the auth id token (OpenId) that will be sent to the server and will be used for providing the `auth` object
+     * to the security rules.
+     *
+     * @param idToken The auth id token, a promise that resolves with the id token, or an observable that emits the id
+     * token. Undefined if the user is not authenticated.
+     * @returns void
+     */
+    setAuthIdToken: (idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>) => void;
+    /**
+     * Returns a reference to the collection in the provided integration.
+     *
+     * If the integrationId is not provided, the `built_in_db` integration id will be used.
+     *
+     * For more information on the CollectionReference object, please refer to the
+     * documentation at {@link https://docs.squid.cloud/docs/client-sdk/collection-reference}.
+     *
+     * @param collectionName The name of the collection.
+     * @param integrationId The id of the integration, default to `built_in_db`.
+     * @returns A reference to the collection in the provided integration.
+     * @typeParam T The type of the documents in the collection.
+     */
+    collection: <T extends DocumentData>(collectionName: CollectionName, integrationId?: IntegrationId) => CollectionReference<T>;
+    /**
+     * Runs the given callback as an atomic change. All the mutations that are executed using the provided transactionId
+     * will be atomic. Note that mutations for different integrations will not be atomic.
+     *
+     * For more information about transactions in Squid, please refer to the
+     * documentation at {@link https://docs.squid.cloud/docs/client-sdk/transactions}.
+     *
+     * @param fn The callback to run as an atomic change. The function receives a transactionId that should be used for
+     * all the mutations that should be atomic. The function should return a promise.
+     *
+     * @returns A promise that resolves when the transactions is committed on the server.
+     */
+    runInTransaction: (fn: (transactionId: TransactionId) => Promise<void>) => Promise<void>;
+    /**
+     * Executes the given backend function with the given parameters and returns a promise with the result.
+     *
+     * For more information about backend functions in Squid, please refer to the
+     * documentation at {@link https://docs.squid.cloud/docs/backend/executables}.
+     *
+     * @param functionName The name of the function to execute on the server.
+     * @param params The parameters to pass to the function.
+     * @returns A promise that resolves with the result of the function.
+     * @typeParam T The type of the result of the function.
+     */
+    executeFunction: <T = any>(functionName: string, ...params: any[]) => Promise<T>;
+    /**
+     * Executes the given named query with the given parameters and returns a promise with the result.
+     *
+     * For more information about named queries in Squid, please refer to the
+     * documentation at {@link https://docs.squid.cloud/docs/backend/named-queries}.
+     *
+     * @param integrationId The id of the integration that the named query is defined with.
+     * @param queryName The name of the named query.
+     * @param params The parameters to pass to the named query.
+     * @returns A promise that resolves with the result of the named query.
+     * @typeParam T The type of the result of the named query.
+     */
+    executeNamedQuery: <T = any>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>) => Promise<T>;
+    /**
+     * Invokes the given HTTP API (defined by the integration ID and the endpoint ID) with the given request parameters
+     * and returns a promise with the response. The structure of the request and the response is defined in the
+     * integration's schema page.
+     *
+     * For more information about API integrations in Squid, please refer to the
+     * documentation at {@link https://docs.squid.cloud/docs/integrations/httpapi}.
+     *
+     * @param integrationId The id of the integration that the API is defined with.
+     * @param endpointId The id of the endpoint in the API integration.
+     * @param request The request parameters to pass to the API.
+     * @returns A promise that resolves with the response of the API.
+     * @typeParam T The type of the response of the API.
+     */
+    callApi: <T = any>(integrationId: IntegrationId, endpointId: ApiEndpointId, request?: Record<string, any>) => Promise<T>;
+    /**
+     * Returns a GraphQL client for the given integration. The GraphQL client can be used to execute GraphQL queries and
+     * mutations. For more information about GraphQL in Squid, please refer to the documentation at
+     * {@link https://docs.squid.cloud/docs/integrations/graphql}.
+     *
+     * @param integrationId The id of the integration that the GraphQL API is defined with.
+     * @returns A GraphQL client for the given integration.
+     */
+    graphql: (integrationId: IntegrationId) => GraphQLClient;
+    /**
+     * Destructs the Squid Client. Unsubscribes from all ongoing queries or requests, and clears the local data.
+     * After invoking this method, the Squid client will not be usable.
+     *
+     * @returns A promise that resolves when the destruct process is complete.
+     */
+    destruct: () => Promise<void>;
+    private validateNotDestructed;
+}

package/dist/typescript-client/src/state/action.applier.d.ts

@@ -1,7 +1,7 @@
-import { BaseAction } from './actions';
-export type StateLeafNode = string | boolean | number | null | undefined | object | Array<StateLeafNode> | State;
-export type State = {
-    [key: string]: StateLeafNode;
-};
-export declare function apply(state: State, action: BaseAction): State;
-export declare function isStateObject(state: StateLeafNode): state is State;
+import { BaseAction } from './actions';
+export type StateLeafNode = string | boolean | number | null | undefined | object | Array<StateLeafNode> | State;
+export type State = {
+    [key: string]: StateLeafNode;
+};
+export declare function apply(state: State, action: BaseAction): State;
+export declare function isStateObject(state: StateLeafNode): state is State;