@squidcloud/client 1.0.102 → 1.0.104

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

@@ -1,218 +1,218 @@
-import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, EnvironmentId, IntegrationId, QueryName, SquidDeveloperId, SupportedSquidRegion } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { AiAssistantClient } from './ai-assistant-client';
-import { CollectionReference } from './collection-reference';
-import { ConnectionDetails } from './connection-details';
-import { DistributedLock } from './distributed-lock.manager';
-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;
-    /**
-     * The environment ID to work with, if not specified the default environment (prod) will be used.
-     */
-    environmentId?: EnvironmentId;
-    /**
-     * The user ID of the developer that runs the environment locally.
-     */
-    squidDeveloperId?: SquidDeveloperId;
-    /**
-     * 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 rpcManager;
-    private readonly dataManager;
-    private readonly documentReferenceFactory;
-    private readonly documentStore;
-    private readonly lockManager;
-    private readonly querySubscriptionManager;
-    private readonly localQueryManager;
-    private readonly queryBuilderFactory;
-    private readonly collectionReferenceFactory;
-    private readonly backendFunctionManager;
-    private readonly namedQueryManager;
-    private readonly apiManager;
-    private readonly graphqlClientFactory;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private readonly distributedLockManager;
-    private readonly authManager;
-    private readonly clientIdService;
-    private readonly aiClientFactory;
-    private readonly _connectionDetails;
-    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.
-     * @param integrationId The id of the integration.
-     * @returns void
-     */
-    setAuthIdToken: (idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>, integrationId?: IntegrationId) => 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/development-tools/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/development-tools/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 are 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/development-tools/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/development-tools/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/api/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/api/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;
-    /**
-     * Returns a set of AI specific clients. Currently, the only supported client is the AI Assistant, which is accessed
-     * through the `assistant`.
-     *
-     * @returns A set of AI specific clients.
-     */
-    ai: () => {
-        /**
-         * Returns an AI Assistant client for the given integration. The AI Assistant client can be used to build and chat
-         * with custom AI profiles. For more information about the AI Assistant in Squid, please refer to the documentation
-         * at {@link https://docs.squid.cloud/docs/ai/ai-assistant}.
-         *
-         * @param integrationId The id of the AI Assistant integration.
-         * @returns An AI Assistant client.
-         */
-        assistant: (integrationId: IntegrationId) => AiAssistantClient;
-    };
-    /**
-     * Returns a distributed lock for the given mutex. The lock can be used to synchronize access to a shared resource.
-     * The lock will be released when the release method on the returned object is invoked or whenever the connection
-     * with the server is lost.
-     * @param mutex A string that uniquely identifies the lock.
-     * @param exclusive Whether the lock should be exclusive or not. If the lock is exclusive, only one client can hold
-     *   the lock.
-     * @returns A promise that resolves with the lock object. The promise will reject if failed to acquire the lock.
-     */
-    acquireLock: (mutex: string, exclusive?: boolean) => Promise<DistributedLock>;
-    /**
-     * 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>;
-    /** Provides information about the connection to the Squid Server. */
-    connectionDetails: () => ConnectionDetails;
-    private validateNotDestructed;
-}
+import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, EnvironmentId, IntegrationId, QueryName, SquidDeveloperId, SupportedSquidRegion } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { AiAssistantClient } from './ai-assistant-client';
+import { CollectionReference } from './collection-reference';
+import { ConnectionDetails } from './connection-details';
+import { DistributedLock } from './distributed-lock.manager';
+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;
+    /**
+     * The environment ID to work with, if not specified the default environment (prod) will be used.
+     */
+    environmentId?: EnvironmentId;
+    /**
+     * The user ID of the developer that runs the environment locally.
+     */
+    squidDeveloperId?: SquidDeveloperId;
+    /**
+     * 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 rpcManager;
+    private readonly dataManager;
+    private readonly documentReferenceFactory;
+    private readonly documentStore;
+    private readonly lockManager;
+    private readonly querySubscriptionManager;
+    private readonly localQueryManager;
+    private readonly queryBuilderFactory;
+    private readonly collectionReferenceFactory;
+    private readonly backendFunctionManager;
+    private readonly namedQueryManager;
+    private readonly apiManager;
+    private readonly graphqlClientFactory;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    private readonly distributedLockManager;
+    private readonly authManager;
+    private readonly clientIdService;
+    private readonly aiClientFactory;
+    private readonly _connectionDetails;
+    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.
+     * @param integrationId The id of the integration.
+     * @returns void
+     */
+    setAuthIdToken: (idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>, integrationId?: IntegrationId) => 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/development-tools/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/development-tools/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 are 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/development-tools/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/development-tools/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/api/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/api/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;
+    /**
+     * Returns a set of AI specific clients. Currently, the only supported client is the AI Assistant, which is accessed
+     * through the `assistant`.
+     *
+     * @returns A set of AI specific clients.
+     */
+    ai: () => {
+        /**
+         * Returns an AI Assistant client for the given integration. The AI Assistant client can be used to build and chat
+         * with custom AI profiles. For more information about the AI Assistant in Squid, please refer to the documentation
+         * at {@link https://docs.squid.cloud/docs/ai/ai-assistant}.
+         *
+         * @param integrationId The id of the AI Assistant integration.
+         * @returns An AI Assistant client.
+         */
+        assistant: (integrationId: IntegrationId) => AiAssistantClient;
+    };
+    /**
+     * Returns a distributed lock for the given mutex. The lock can be used to synchronize access to a shared resource.
+     * The lock will be released when the release method on the returned object is invoked or whenever the connection
+     * with the server is lost.
+     * @param mutex A string that uniquely identifies the lock.
+     * @param exclusive Whether the lock should be exclusive or not. If the lock is exclusive, only one client can hold
+     *   the lock.
+     * @returns A promise that resolves with the lock object. The promise will reject if failed to acquire the lock.
+     */
+    acquireLock: (mutex: string, exclusive?: boolean) => Promise<DistributedLock>;
+    /**
+     * 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>;
+    /** Provides information about the connection to the Squid Server. */
+    connectionDetails: () => ConnectionDetails;
+    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;

package/dist/typescript-client/src/state/actions.d.ts

@@ -1,29 +1,29 @@
-import { StateLeafNode } from './action.applier';
-export declare enum ActionType {
-    DELETE_PATH = "DELETE_PATH",
-    SET_PATH = "SET_PATH",
-    BATCH_ACTION = "BATCH_ACTION"
-}
-export declare interface BaseAction {
-    type: ActionType;
-}
-export declare interface PathAction extends BaseAction {
-    path: string[];
-}
-export type DeletePathAction = PathAction;
-export declare interface SetPathAction extends PathAction {
-    payload?: StateLeafNode;
-}
-export declare interface BatchAction extends BaseAction {
-    payload: BaseAction[];
-}
-export declare interface StateMessage {
-    type: 'ACTIONS';
-    payload: BaseAction[];
-}
-export declare function isPathAction(action: BaseAction): action is PathAction;
-export declare function isSetPathAction(action: BaseAction): action is SetPathAction;
-export declare function isDeletePathAction(action: BaseAction): action is DeletePathAction;
-export declare function isBatchAction(action: BaseAction): action is BatchAction;
-export declare function extractAllPathActions(action: BaseAction): PathAction[];
-export declare function getSingleAction(actions: BaseAction[]): BaseAction;
+import { StateLeafNode } from './action.applier';
+export declare enum ActionType {
+    DELETE_PATH = "DELETE_PATH",
+    SET_PATH = "SET_PATH",
+    BATCH_ACTION = "BATCH_ACTION"
+}
+export declare interface BaseAction {
+    type: ActionType;
+}
+export declare interface PathAction extends BaseAction {
+    path: string[];
+}
+export type DeletePathAction = PathAction;
+export declare interface SetPathAction extends PathAction {
+    payload?: StateLeafNode;
+}
+export declare interface BatchAction extends BaseAction {
+    payload: BaseAction[];
+}
+export declare interface StateMessage {
+    type: 'ACTIONS';
+    payload: BaseAction[];
+}
+export declare function isPathAction(action: BaseAction): action is PathAction;
+export declare function isSetPathAction(action: BaseAction): action is SetPathAction;
+export declare function isDeletePathAction(action: BaseAction): action is DeletePathAction;
+export declare function isBatchAction(action: BaseAction): action is BatchAction;
+export declare function extractAllPathActions(action: BaseAction): PathAction[];
+export declare function getSingleAction(actions: BaseAction[]): BaseAction;

package/dist/typescript-client/src/state/path_trie.d.ts

@@ -1,27 +1,27 @@
-import { BaseAction } from './actions';
-export declare class PathTrie<T> {
-    private root;
-    getOrCreatePathTrieNode(path: string[], nodeData?: T): PathTrieNode<T>;
-    getPathTrieNode(path: string[]): PathTrieNode<T> | undefined;
-    getPathTrie(path: string[]): PathTrie<T> | undefined;
-    /**
-     * If the callback returns false, it will not iterate into the children of the current node.
-     */
-    iterateBfs(callback: (data: T, path: string[]) => void | boolean): void;
-    removeNode(path: string[]): void;
-    clearNodeData(path: string[]): void;
-    getNodeList(path: string[]): Array<PathTrieNode<T>>;
-    private iterateInternal;
-}
-export declare class PathTrieNode<T> {
-    children: Map<string, PathTrieNode<T>>;
-    nodeData: T | undefined;
-}
-/**
- * Returns a trie which contains all the paths affected by the action. For
- * example, if the action contains a path action applied on path [A, B, C], then
- * [A], [A, B], [A, B, C] will be in the returned trie. Moreover, if
- * subscriptionTree is provided and contains [A, B, C, ...], then [A, B, C, ...]
- * will also be included in the returned trie.
- */
-export declare function getPathTrieFromAction(action: BaseAction, subscriptionTree?: PathTrie<{}>): PathTrie<boolean>;
+import { BaseAction } from './actions';
+export declare class PathTrie<T> {
+    private root;
+    getOrCreatePathTrieNode(path: string[], nodeData?: T): PathTrieNode<T>;
+    getPathTrieNode(path: string[]): PathTrieNode<T> | undefined;
+    getPathTrie(path: string[]): PathTrie<T> | undefined;
+    /**
+     * If the callback returns false, it will not iterate into the children of the current node.
+     */
+    iterateBfs(callback: (data: T, path: string[]) => void | boolean): void;
+    removeNode(path: string[]): void;
+    clearNodeData(path: string[]): void;
+    getNodeList(path: string[]): Array<PathTrieNode<T>>;
+    private iterateInternal;
+}
+export declare class PathTrieNode<T> {
+    children: Map<string, PathTrieNode<T>>;
+    nodeData: T | undefined;
+}
+/**
+ * Returns a trie which contains all the paths affected by the action. For
+ * example, if the action contains a path action applied on path [A, B, C], then
+ * [A], [A, B], [A, B, C] will be in the returned trie. Moreover, if
+ * subscriptionTree is provided and contains [A, B, C, ...], then [A, B, C, ...]
+ * will also be included in the returned trie.
+ */
+export declare function getPathTrieFromAction(action: BaseAction, subscriptionTree?: PathTrie<{}>): PathTrie<boolean>;

package/dist/typescript-client/src/state/state.service.d.ts

@@ -1,22 +1,22 @@
-import { Observable } from 'rxjs';
-import { State, StateLeafNode } from './action.applier';
-import { BaseAction } from './actions';
-export declare class StateService {
-    private readonly subscriptionsTree;
-    private state;
-    private batchCount;
-    private readonly batchedActions;
-    dispatch(action: BaseAction): void;
-    runInBatch(fn: () => unknown): void;
-    observePath<T>(path: string[], pathsToExcludeFn?: () => Array<string[]>): Observable<T>;
-    setKeyInPath<T extends State>(path: string[], key: keyof T & string, value: T[keyof T] & StateLeafNode, noopIfSame?: boolean): void;
-    setPartial<T extends State>(path: string[], partialState: Partial<T>, noopIfSame?: boolean): void;
-    setInPath(path: string[], payload: StateLeafNode, noopIfSame?: boolean): void;
-    pushToArray(path: string[], payload: StateLeafNode): void;
-    deletePath(path: string[]): void;
-    getState(): State;
-    getStateInPath<T extends StateLeafNode>(path: string[]): T;
-    destroy(): void;
-    private getOrCreateSubjectForPath;
-    private dispatchSubscriptions;
-}
+import { Observable } from 'rxjs';
+import { State, StateLeafNode } from './action.applier';
+import { BaseAction } from './actions';
+export declare class StateService {
+    private readonly subscriptionsTree;
+    private state;
+    private batchCount;
+    private readonly batchedActions;
+    dispatch(action: BaseAction): void;
+    runInBatch(fn: () => unknown): void;
+    observePath<T>(path: string[], pathsToExcludeFn?: () => Array<string[]>): Observable<T>;
+    setKeyInPath<T extends State>(path: string[], key: keyof T & string, value: T[keyof T] & StateLeafNode, noopIfSame?: boolean): void;
+    setPartial<T extends State>(path: string[], partialState: Partial<T>, noopIfSame?: boolean): void;
+    setInPath(path: string[], payload: StateLeafNode, noopIfSame?: boolean): void;
+    pushToArray(path: string[], payload: StateLeafNode): void;
+    deletePath(path: string[]): void;
+    getState(): State;
+    getStateInPath<T extends StateLeafNode>(path: string[]): T;
+    destroy(): void;
+    private getOrCreateSubjectForPath;
+    private dispatchSubscriptions;
+}

package/dist/typescript-client/src/state/state.service.spec.d.ts

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

package/dist/typescript-client/src/testing/setup-tests.d.ts

@@ -1 +1 @@
-declare const nodeCrypto: any;
+declare const nodeCrypto: any;

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

@@ -1,2 +1,2 @@
-/** A transactionId - alias for string */
-export type TransactionId = string;
+/** A transactionId - alias for string */
+export type TransactionId = string;