@squidcloud/client 1.0.28 → 1.0.30

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/index.js",
   "types": "dist/typescript-client/src/index.d.ts",

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

@@ -1,9 +1,16 @@
-import { DocId, DocIdObj, DocumentData, IdResolutionMap, IntegrationId } from '@squidcloud/common';
+import { DocId, DocIdObj, DocumentData } from '@squidcloud/common';
 import { DocumentReference } from './document-reference';
-import { DocumentReferenceFactory } from './document-reference.factory';
-import { JoinQueryBuilder, JoinQueryBuilderFactory } from './query/join-query-builder.factory';
-import { QueryBuilder, QueryBuilderFactory } from './query/query-builder.factory';
+import { JoinQueryBuilder } from './query/join-query-builder.factory';
+import { QueryBuilder } from './query/query-builder.factory';
 import { Alias } from './query/query.types';
+/**
+ *  Holds a reference to a data collection. a collection reference is a reference to a collection in a database. You can
+ *  use it to read or write data to the collection. A collection can refer to a table in a relational database or a
+ *  collection in a NoSQL database.
+ *
+ * Read more about collection references in the [documentation]{@link https://docs.squid.cloud/docs/client-sdk/collection-reference}.
+ * @typeParam T The type of the document data.
+ */
 export declare class CollectionReference<T extends DocumentData> {
     private readonly collectionName;
     private integrationId;
@@ -11,9 +18,34 @@ export declare class CollectionReference<T extends DocumentData> {
     private readonly queryBuilderFactory;
     private readonly joinQueryBuilderFactory;
     private readonly documents;
-    constructor(collectionName: string, integrationId: IntegrationId, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, joinQueryBuilderFactory: JoinQueryBuilderFactory);
+    /**
+     * Returns a document reference for the given document id.
+     * The document id is an object that maps the primary keys of the collection (as defined in the Squid Cloud Console)
+     * to their values. There are two exceptions:
+     * 1 - If no document id is provided, a new document id will be generated on the server once the document is created.
+     * This is true only if the underlying datasource for this collection supports id generation.
+     * 2 - If the integration id is `built_in_db`, the document id may be a string unless a primary key was provided for
+     * this collection in the Squid Cloud Console.
+     *
+     * @param docId The document id as an object for the different fields in the primary key or a string. If none is provided,
+     * a new document id will be generated on the server once the document is created (if the integration supports it).
+     *
+     * @returns A document reference for the given document id.
+     */
     doc(docId?: DocId | DocIdObj): DocumentReference<T>;
+    /**
+     * Creates a `QueryBuilder` that can be used to query the collection.
+     *
+     * @returns A `QueryBuilder` that can be used to query the collection.
+     */
     query(): QueryBuilder<T>;
+    /**
+     * Creates a `JoinQueryBuilder` that can be used to query the collection
+     * Note that when using a join query, you have to provide an alias for the query and for every other query
+     * participating in the join.
+     *
+     * @param alias The alias for the query.
+     * @returns A `JoinQueryBuilder` that can be used to query the collection and joins with other queries.
+     */
     joinQuery<A extends Alias>(alias: A): JoinQueryBuilder<T, A, Record<A, DocumentReference<T>>>;
-    migrateDocIds(idResolutionMap: IdResolutionMap): void;
 }

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

@@ -2,7 +2,7 @@ export type DestructorFn = () => Promise<void> | void;
 export declare class DestructManager {
     private readonly predestructors;
     private readonly destructors;
-    private isDestructed;
+    isDestructed: boolean;
     onPreDestruct(fn: DestructorFn): void;
     onDestruct(fn: DestructorFn): void;
     destruct(): Promise<void>;

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

@@ -1,23 +1,91 @@
-import { DocumentData, IdResolutionMap, Paths, SquidDocId } from '@squidcloud/common';
+import { DocumentData, IdResolutionMap, Paths } from '@squidcloud/common';
 import { Observable } from 'rxjs';
-import { DataManager } from './data.manager';
-import { QueryBuilderFactory } from './query/query-builder.factory';
 import { TransactionId } from './types';
+/**
+ * Holds a reference to a document. A document reference is a reference to a specific record in a collection. You can
+ * use it to read or write data to the document. A document can refer to a row in a table in a relational database or a
+ * document in a NoSQL database. Additionally, a document reference can refer to a non-existent document, which you can
+ * use to create a new document.
+ *
+ * Read more about document references in the
+ * [documentation]{@link https://docs.squid.cloud/docs/client-sdk/document-reference}.
+ * @typeParam T The type of the document data.
+ */
 export declare class DocumentReference<T extends DocumentData = any> {
     private _squidDocId;
     private readonly dataManager;
     private readonly queryBuilderFactory;
-    constructor(_squidDocId: SquidDocId, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
-    get squidDocId(): SquidDocId;
-    data(): T;
+    /**
+     * Returns the document data. Throws an error if the document does not exist.
+     *
+     * @returns The document data.
+     * @throws Error if the document does not exist.
+     */
+    get data(): T;
+    /**
+     * Returns a document reference with the latest data from the server or undefined if the document does not exist on
+     * the server.
+     *
+     * @returns A document reference with the latest data from the server or undefined if the document does not exist on
+     * the server.
+     */
     snapshot(): Promise<DocumentReference<T> | undefined>;
+    /**
+     * Returns an observable that emits a document reference with the latest data from the server or undefined if the
+     * document is deleted or does not exist on the server.
+     *
+     * @returns An observable that emits a document reference with the latest data from the server or undefined if the
+     * document is deleted or does not exist on the server.
+     */
     snapshots(): Observable<DocumentReference<T> | undefined>;
+    /**
+     * Returns whether the locally available version of the document may not be the latest version on the server.
+     *
+     * @returns Whether the locally available version of the document may not be the latest version on the server.
+     */
     isDirty(): boolean;
     private isTracked;
+    /**
+     * Updates the document with the given data.
+     * The `update` will be reflected optimistically locally and will be applied to the server later.
+     * If a transactionId is provided, the `update` will be applied to the server as an atomic operation together with
+     * the rest of the operations in the transaction and the `update` will not reflect locally until the transaction is
+     * completed locally.
+     *
+     * The returned promise will resolve once the `update` has been applied to the server or immediately if the `update`
+     * is part of a transaction.
+     *
+     * @param data The data to update - can be partial.
+     */
     update(data: Partial<Record<Paths<T>, any>>, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Similar to {@link update}, but only updates the given path.
+     */
     setInPath(path: Paths<T>, value: any, transactionId?: TransactionId): Promise<void>;
+    /** Similar to `update`, but only deletes the given path. */
     deleteInPath(path: Paths<T>, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Inserts the document with the given data. If the document already exists, the operation will be treated as
+     * `upsert`. The `insert` will be reflected optimistically locally and will be applied to the server later. If a
+     * transactionId is provided, the `insert` will be applied to the server as an atomic operation together with the
+     * rest
+     * of the operations in the transaction and the `insert` will not reflect locally until the transaction is completed
+     * locally.
+     *
+     * The returned promise will resolve once the `insert` has been applied to the server or immediately if the `insert`
+     * is part of a transaction.
+     */
     insert(data: T, transactionId?: TransactionId): Promise<void>;
+    /**
+     * Deletes the document.
+     * The `delete` will be reflected optimistically locally and will be applied to the server later.
+     * If a transactionId is provided, the `delete` will be applied to the server as an atomic operation together with
+     * the rest of the operations in the transaction and the `delete` will not reflect locally until the transaction is
+     * completed locally.
+     *
+     * The returned promise will resolve once the `delete` has been applied to the server or immediately if the `delete`
+     * is part of a transaction.
+     */
     delete(transactionId?: TransactionId): Promise<void>;
     migrateDocIds(idResolutionMap: IdResolutionMap): void;
 }

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

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

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

@@ -1,17 +1,11 @@
-import { CollectionName, DocumentData, FieldName, IntegrationId, Operator, PrimitiveFieldType, Query } from '@squidcloud/common';
+import { DocumentData, FieldName, Operator, PrimitiveFieldType } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import { DocumentReference } from '../document-reference';
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { QueryBuilderFactory } from './query-builder.factory';
-import { QuerySubscriptionManager } from './query-subscription.manager';
 import { Alias } from './query.types';
-export declare class JoinQueryBuilderFactory {
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory);
-    getForJoin<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType>>>(collectionName: CollectionName, integrationId: IntegrationId, alias: MyAlias): JoinQueryBuilder<DocumentType, MyAlias, ReturnType>;
-}
+/**
+ * A query builder that can participate in a join.
+ * To learn more about join queries, see {@link https://docs.squid.cloud/docs/client-sdk/queries#joining-data-across-collections-and-integrations}.
+ */
 export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType> | undefined>> {
     private readonly collectionName;
     private readonly integrationId;
@@ -24,12 +18,54 @@ export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias
     private readonly joins;
     /** Record that maps the right alias to the left condition */
     private readonly joinConditions;
-    constructor(collectionName: CollectionName, integrationId: IntegrationId, querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, alias: MyAlias, joinQueryBuilderFactory: JoinQueryBuilderFactory, queryBuilderFactory: QueryBuilderFactory);
+    /**
+     * Adds a condition to the query.
+     *
+     * @param fieldName The name of the field to query
+     * @param operator The operator to use
+     * @param value The value to compare against
+     * @returns The query builder
+     */
     where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /**
+     * Sets a limit to the number of results returned by the query. The maximum limit is 1000 and this is the default if
+     * none is provided.
+     *
+     * @param limit The maximum number of results to return
+     * @returns The query builder
+     */
     limit(limit: number): this;
+    /**
+     * Adds a sort order to the query. You can add multiple sort orders to the query. The order in which you add them
+     * determines the order in which they are applied.
+     * @param fieldName The name of the field to sort by
+     * @param asc Whether to sort in ascending order. Defaults to true.
+     * @returns The query builder
+     */
     sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
+    /**
+     * Joins this query with another join query and return a new query builder that can be used to query the joined
+     * documents.
+     * @param queryBuilder The query builder to join with
+     * @param leftFieldName The name of the field on the left side of the join
+     * @param rightFieldName The name of the field on the right side of the join
+     * @returns A new query builder that can be used to query the joined documents
+     */
     join<J extends DocumentData, RightAlias extends Alias, RightReturnType extends Record<RightAlias, DocumentReference<J> | undefined>>(queryBuilder: JoinQueryBuilder<J, RightAlias, RightReturnType>, leftFieldName: keyof DocumentType & FieldName, rightFieldName: keyof J & FieldName): JoinQueryBuilder<DocumentType, MyAlias, ReturnType & Partial<RightReturnType>>;
+    /**
+     * Returns a promise that resolves to the query results.
+     *
+     * @returns A promise that resolves to the query results
+     */
     snapshot(): Promise<Array<ReturnType>>;
+    /**
+     * Returns an observable that emits the query results and updates whenever the query results change unless
+     * `subscribe=false` is provided.
+     *
+     * Important: Make sure to unsubscribe from the observable when you are done with it.
+     *
+     * @param subscribe Whether to subscribe to the query. Defaults to true.
+     * @returns An observable for the query results
+     */
     snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
-    build(): Query;
 }

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

@@ -1,4 +1,4 @@
-import { CollectionName, DocumentData, FieldName, IntegrationId, Operator, PrimitiveFieldType, Query, SquidDocId } from '@squidcloud/common';
+import { CollectionName, DocumentData, IntegrationId, SimpleQueryBuilder, SquidDocId } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import DocumentIdentityService from '../document-identity.service';
 import { DocumentReference } from '../document-reference';
@@ -12,26 +12,42 @@ export declare class QueryBuilderFactory {
     getForDocument<DocumentType extends DocumentData>(squidDocId: SquidDocId): QueryBuilder<DocumentType>;
     get<DocumentType extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): QueryBuilder<DocumentType>;
 }
-export declare class QueryBuilder<DocumentType extends DocumentData> {
-    private readonly collectionName;
-    private readonly integrationId;
+/** A query builder that can be used to build a query that returns a list of documents. */
+export declare class QueryBuilder<DocumentType extends DocumentData> extends SimpleQueryBuilder<DocumentType> {
     private readonly querySubscriptionManager;
     private readonly documentReferenceFactory;
     private readonly queryBuilderFactory;
     private readonly documentIdentityService;
-    private readonly simpleQueryBuilder;
-    constructor(collectionName: CollectionName, integrationId: IntegrationId, querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, documentIdentityService: DocumentIdentityService);
-    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    limit(limit: number): this;
-    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
+    /**
+     * Returns a promise that resolves to the query results.
+     *
+     * @returns A promise that resolves to the query results.
+     */
     snapshot(): Promise<Array<DocumentReference<DocumentType>>>;
+    /**
+     * Returns an observable that emits the query results and updates whenever the query results change unless
+     * `subscribe=false` is provided.
+     *
+     * Important: Make sure to unsubscribe from the observable when you are done with it.
+     *
+     * @param subscribe Whether to subscribe to changes to the query results. Defaults to `true`.
+     * @returns An observable for the query results.
+     */
     snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
+    /**
+     * Similar to `snapshots` but returns an observable that emits the changes to the query results. The first result
+     * will contain only inserts.
+     *
+     * @returns An observable for the query changes.
+     */
     changes(): Observable<Changes<DocumentType>>;
-    build(): Query;
-    get hash(): string;
 }
+/** Describes the changes to a query result. */
 export interface Changes<DocumentType extends DocumentData> {
+    /** The newly inserted documents to the query result */
     inserts: Array<DocumentReference<DocumentType>>;
+    /** The documents that were updated in the query result */
     updates: Array<DocumentReference<DocumentType>>;
+    /** The actual document data that was deleted from the query result */
     deletes: Array<DocumentType>;
 }

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

@@ -1,5 +1,12 @@
 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;

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

@@ -2,14 +2,41 @@ import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, Integration
 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>;
 }
-/** Reference to the squid db. Provides all the available actions on the DB. */
+/**
+ * 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;
@@ -29,23 +56,116 @@ export declare class Squid {
     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);
     /**
-     * This method is a factory method for creating a Squid instance
+     * 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
+     * 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.
+     * @returns void
+     */
+    setAuthIdToken: (idToken: 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.
      */
-    setAuthIdToken(idToken: string | undefined): void;
-    collection<T extends DocumentData>(collectionName: CollectionName, integrationId?: IntegrationId): CollectionReference<T>;
-    runInTransaction(fn: (transactionId: TransactionId) => Promise<void>): Promise<void>;
-    executeFunction<T = any>(functionName: string, ...params: any[]): Promise<T>;
-    executeNamedQuery<T = any>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>): Promise<T>;
-    callApi<T = any>(integrationId: IntegrationId, endpointId: ApiEndpointId, request?: Record<string, any>): Promise<T>;
-    graphql(integrationId: IntegrationId): GraphQLClient;
-    destruct(): Promise<void>;
-    unsubscribe(): Promise<void>;
+    destruct: () => Promise<void>;
+    private validateNotDestructed;
 }

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

@@ -1,2 +1,2 @@
+/** A transactionId - alias for string */
 export type TransactionId = string;
-export declare const NOOP_FN: (fn: () => any) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/index.js",
   "types": "dist/typescript-client/src/index.d.ts",

package/dist/common/src/metrics.schemas.d.ts

@@ -1,3 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { GetMetricDataRequest } from './metrics.types';
-export declare const GetMetricDataRequestSchema: JSONSchemaType<GetMetricDataRequest>;