@squidcloud/client 1.0.145 → 1.0.146-beta

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

@@ -1,269 +1,378 @@
-import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, EnvironmentId, IntegrationId, QueryName, SquidDeveloperId, SupportedSquidRegion } from '@squidcloud/common';
-import { CollectionReference } from './collection-reference';
-import { ConnectionDetails } from './connection-details';
-import { DistributedLock } from './distributed-lock.manager';
-import { GraphQLClient } from './graphql-client';
-import { SecretClient } from './secret.client';
-import { TransactionId } from './types';
-import { AiClient } from './ai.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;
-    /**
-     * Access token provider for the Squid instance.
-     * Used for managing the process of verifying the identity and authorization of users who attempt to access this
-     * application via the current Squid instance.
-     *
-     * When the authProvider is set, the Squid service will fetch a token and include it with every request to the Squid
-     * backend.
-     *
-     * On the backend, Squid will validate the access token.
-     */
-    authProvider?: SquidAuthProvider;
-    /**
-     * 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>;
-}
-/** Authentication data provider for Squid requests. */
-export interface SquidAuthProvider {
-    /**
-     * Returns a valid AccessToken.
-     * Called by Squid every time a Squid client makes requests to the Squid backend.
-     */
-    getToken(): Promise<string | undefined>;
-    /**
-     * Optional Auth integration id.
-     * Sent as a part of all Squid requests to the backend.
-     */
-    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 {
-    readonly options: SquidOptions;
-    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 nativeQueryManager;
-    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 readonly secretClient;
-    private readonly querySender;
-    private static readonly squidInstancesMap;
-    private readonly aiClient;
-    /**
-     * 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 authorization access token (OAuth2.0) provider that will be sent to the server and will be used for
-     * providing the `auth` object to the security rules.
-     *
-     * @param authProvider The OAuth2.0 access token provider invoked for every backend request by Squid.
-     *    When the provider returns undefined, no authorization information is sent.
-     *    When a new provider is set, all future Squid backend requests will use the new token provider, and exising
-     *    in-flight requests won't be affected.
-     * @returns void
-     */
-    setAuthProvider(authProvider: SquidAuthProvider): 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
-     * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/collection-reference documentation}.
-     *
-     * @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
-     * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/transactions documentation}.
-     *
-     * @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: <T = any>(fn: (transactionId: TransactionId) => Promise<T>) => Promise<T>;
-    /**
-     * 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
-     * {@link https://docs.squid.cloud/docs/development-tools/backend/executables documentation}.
-     *
-     * @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
-     * {@link https://docs.squid.cloud/docs/development-tools/backend/named-queries documentation}.
-     *
-     * @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[]>;
-    /**
-     * Executes a native relational query with the given parameters and returns a promise with the result.
-     *
-     * Native queries allow you to execute raw SQL or other database-specific queries directly against the database.
-     * This can be useful when you need to perform operations that are not easily accomplished with named queries or
-     * other high-level abstractions.
-     *
-     * @param integrationId The id of the integration that the query is associated with.
-     * @param query The raw SQL or other database-specific query to execute.
-     * @param params (Optional) The parameters to pass to the query. Defaults to an empty object.
-     * @returns A promise that resolves with the result of the query.
-     * @type {Promise<Array<SquidDocument>>}
-     */
-    executeNativeRelationalQuery: <T = any>(integrationId: IntegrationId, query: string, params?: Record<string, any>) => Promise<T[]>;
-    /**
-     * Executes a native MongoDB aggregation pipeline with the given parameters and returns a promise with the result.
-     *
-     * Native queries allow you to execute raw MongoDB queries directly against the database.
-     * This can be particularly useful when you need to perform complex operations or aggregations that are not
-     * easily accomplished with standard query methods or other high-level abstractions provided by the database driver
-     * or ORM.
-     *
-     * @param {IntegrationId} integrationId - The id of the integration that the query is associated with.
-     * @param {string} collectionName - The name of the MongoDB collection to run the aggregation pipeline against.
-     * @param {Array<Record<string, any>>} [aggregationPipeline=[]] - The array of aggregation stages to be executed.
-     *        Each stage in the pipeline is an object specifying the operation to be performed.
-     * @returns {Promise<Array<T>>} A promise that resolves with an array of documents resulting from the aggregation
-     *   pipeline. Each document in the array is of the generic type T, which can be specified when calling the function.
-     * @template T - The type of the documents that are expected to be returned by the aggregation pipeline. If not
-     *   specified, any type is assumed by default.
-     * @type {Promise<Array<SquidDocument>>}
-     */
-    executeNativeMongoQuery: <T = any>(integrationId: IntegrationId, collectionName: string, aggregationPipeline?: Array<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
-     * {@link https://docs.squid.cloud/docs/integrations/api/httpapi documentation}.
-     *
-     * @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
-     * {@link https://docs.squid.cloud/docs/integrations/api/graphql documentation}.
-     *
-     * @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.
-     *
-     * @returns A set of AI specific clients.
-     */
-    ai: () => AiClient;
-    get secrets(): SecretClient;
-    /**
-     * 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.
-     * @returns A promise that resolves with the lock object. The promise will reject if failed to acquire the lock.
-     */
-    acquireLock: (mutex: string) => 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 { AdminClient } from './admin-client';
+import { AiClient } from './ai-client';
+import { ApiClient } from './api-client';
+import { CollectionReference } from './collection-reference';
+import { ConnectionDetails } from './connection-details';
+import { DistributedLock, DistributedLockOptions } from './distributed-lock.manager';
+import { ExecuteFunctionOptions } from './execute-function-options';
+import { ExternalAuthClient } from './external-auth-client';
+import { ExtractionClient } from './extraction-client';
+import { JobClient } from './job-client';
+import { NotificationClient } from './notification-client';
+import { ObservabilityClient } from './observability-client';
+import { ApiKey, AppId, CollectionName, DocumentData, EnvironmentId, IntegrationId, SquidDeveloperId, SquidRegion } from './public-types';
+import { QueueManager } from './queue.manager';
+import { SchedulerClient } from './scheduler-client';
+import { StorageClient } from './storage-client';
+import { TransactionId } from './types';
+import { WebClient } from './web-client';
+import { ExecuteWebhookOptions } from './webhook.manager';
+/**
+ * The different options that can be used to initialize a Squid instance.
+ * @category Platform
+ */
+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 Console.
+     */
+    apiKey?: ApiKey;
+    /**
+     * Access token provider for the Squid instance.
+     * Used for managing the process of verifying the identity and authorization of users who attempt to access this
+     * application via the current Squid instance.
+     *
+     * When the authProvider is set, the Squid service will fetch a token and include it with every request to the Squid
+     * backend.
+     *
+     * On the backend, Squid will validate the access token.
+     */
+    authProvider?: SquidAuthProvider;
+    /**
+     * The region that the application is running in. This is used to determine the URL of the Squid API.
+     */
+    region: SquidRegion;
+    /**
+     * 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;
+    /**
+     * The console region (optional and used for on-prem deployments of Squid)
+     */
+    consoleRegion?: string;
+}
+/**
+ * Authentication data provider for Squid requests.
+ * @category Authentication
+ */
+export interface SquidAuthProvider {
+    /**
+     * Optional Auth integration id.
+     * Sent as a part of all Squid requests to the backend.
+     */
+    integrationId: string;
+    /**
+     * Returns a valid AccessToken or undefined if there is no active authorized session.
+     * Called by Squid every time a Squid client makes requests to the Squid backend.
+     */
+    getToken(): Promise<string | undefined> | string | undefined;
+}
+/**
+ * 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.
+ * All public Squid functions are bound to `this` and can be used with a destructuring patterns,
+ * like `const {setAuthProvider} = useSquid()`
+ *
+ * @category Platform
+ */
+export declare class Squid {
+    readonly options: SquidOptions;
+    private static readonly squidInstancesMap;
+    private readonly socketManager;
+    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 webhookManager;
+    private readonly nativeQueryManager;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    private readonly distributedLockManager;
+    private readonly authManager;
+    private readonly clientIdService;
+    private readonly _connectionDetails;
+    private readonly querySender;
+    private readonly aiClient;
+    private readonly jobClient;
+    private readonly apiClient;
+    private readonly adminClient;
+    private readonly webClient;
+    private readonly observabilityClient;
+    private readonly queueManagerFactory;
+    private readonly schedulerClient;
+    private readonly notificationClient;
+    private readonly _appId;
+    /**
+     * Creates a new instance of Squid with the given options.
+     *
+     * @param options The options for initializing the Squid instance.
+     */
+    constructor(options: SquidOptions);
+    /**
+     * Returns the observability client for metrics.
+     */
+    get observability(): ObservabilityClient;
+    /**
+     * Returns the scheduler client for managing scheduled jobs and tasks.
+     */
+    get schedulers(): SchedulerClient;
+    /**
+     * Returns the application ID of the current Squid instance.
+     */
+    get appId(): AppId;
+    /**
+     * 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 authorization access token (OAuth2.0) provider that will be sent to the server and will be used for
+     * providing the `auth` object to the security rules.
+     *
+     * @param authProvider The OAuth2.0 access token provider invoked for every backend request by Squid.
+     *    When the provider returns undefined, no authorization information is sent.
+     *    When a new provider is set, all future Squid backend requests will use the new token provider, and exising
+     *    in-flight requests won't be affected.
+     * @returns void.
+     */
+    setAuthProvider(authProvider: SquidAuthProvider): 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
+     * {@link https://docs.getsquid.ai/docs/sdk/client-sdk/database/collection-reference documentation}.
+     *
+     * @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
+     * {@link https://docs.getsquid.ai/docs/sdk/client-sdk/database/transactions documentation}.
+     *
+     * @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<T = any>(fn: (transactionId: TransactionId) => Promise<T>): Promise<T>;
+    /**
+     * Executes a backend function identified by its name, passing the provided parameters, and returns a promise with
+     * the result.
+     *
+     * For detailed information on backend functions in Squid, see the
+     * {@link https://docs.getsquid.ai/docs/sdk/backend-sdk/executables documentation}.
+     *
+     * Files support:
+     * - To send a file to the backend, simply include it as one of the parameters; it will be received as a `SquidFile`
+     * on the backend.
+     * - Arrays of files can also be passed directly as parameters.
+     *
+     * @param functionNameOrOptions - The name of the backend function to execute or detailed options which include
+     *   additional advanced options along with the function name.
+     * @param params - A list of parameters to pass to the backend function.
+     * @returns A promise that resolves to the result of the backend function.
+     * @typeParam T - The expected type of the result returned by the backend function.
+     */
+    executeFunction<T = any>(functionNameOrOptions: string | ExecuteFunctionOptions<T>, ...params: Array<any | File>): Promise<T>;
+    /**
+     * Executes a backend function with custom headers, passing the provided parameters, and returns a promise with
+     * the result. The headers will be accessible in the backend via `this.context.headers`.
+     *
+     * For detailed information on backend functions in Squid, see the
+     * {@link https://docs.getsquid.ai/docs/sdk/backend-sdk/executables documentation}.
+     *
+     * Files support:
+     * - To send a file to the backend, simply include it as one of the parameters; it will be received as a `SquidFile`
+     * on the backend.
+     * - Arrays of files can also be passed directly as parameters.
+     *
+     * @param functionNameOrOptions - The name of the backend function to execute or detailed options which include
+     *   additional advanced options along with the function name.
+     * @param headers - Custom HTTP headers to send with the request. These headers will be available in the backend
+     *   function via `this.context.headers`.
+     * @param params - A list of parameters to pass to the backend function.
+     * @returns A promise that resolves to the result of the backend function.
+     * @typeParam T - The expected type of the result returned by the backend function.
+     */
+    executeFunctionWithHeaders<T = any>(functionNameOrOptions: string | ExecuteFunctionOptions<T>, headers: Record<string, string>, ...params: Array<any | File>): Promise<T>;
+    /**
+     * Executes a webhook identified by its ID, passing the provided options, and returns a promise with the result.
+     *
+     * For detailed information on webhooks in Squid, see the
+     * {@link https://docs.getsquid.ai/docs/sdk/backend-sdk/webhooks documentation}.
+     *
+     * Files support:
+     * - To send files to the webhook, include them in the options.files array; they will be received as `SquidFile`
+     * objects on the backend.
+     *
+     * @param webhookId - The ID of the webhook to execute.
+     * @param options - Optional configuration including headers, query parameters, body, and files.
+     * @returns A promise that resolves to the result of the webhook execution.
+     * @typeParam T - The expected type of the result returned by the webhook.
+     */
+    executeWebhook<T = any>(webhookId: string, options?: ExecuteWebhookOptions): Promise<T>;
+    /**
+     * Executes a native relational query with the given parameters and returns a promise with the result.
+     * See https://docs.getsquid.ai/docs/sdk/client-sdk/database/native-queries.
+     *
+     * @param integrationId The id of the integration that the query is associated with.
+     * @param query The raw SQL or database-specific query string to execute. Use named bind variables enclosed in ${},
+     *   e.g., ${firstName}.
+     * @param params (Optional) An object containing key-value pairs to bind to the query variables. Defaults to an empty
+     *   object.
+     * @returns A promise that resolves with the result of the query.
+     */
+    executeNativeRelationalQuery<T = any>(integrationId: IntegrationId, query: string, params?: Record<string, any>): Promise<Array<T>>;
+    /**
+     * Executes a native pure query with the given parameters and returns a promise with the result.
+     * See https://docs.getsquid.ai/docs/sdk/client-sdk/database/native-queries.
+     *
+     * @param integrationId The id of the integration that the query is associated with.
+     * @param query The raw SQL or database-specific query string to execute. Use named bind variables enclosed in ${},
+     *   e.g., ${firstName}.
+     * @param params (Optional) An object containing key-value pairs to bind to the query variables. Defaults to an empty
+     *   object.
+     * @returns A promise that resolves with the result of the query.
+     */
+    executeNativePureQuery<T = any>(integrationId: IntegrationId, query: string, params?: Record<string, any>): Promise<Array<T>>;
+    /**
+     * Executes a native Mongo/built-in-db query with the given pipeline and returns a promise with the result.
+     * See https://docs.getsquid.ai/docs/sdk/client-sdk/database/native-queries#native-mongodb-queries.
+     *
+     * @param integrationId The id of the integration that the query is associated with.
+     * @param collectionName The collection to query.
+     * @param aggregationPipeline The aggregation pipeline for the query.
+     * @returns A promise that resolves with the result of the query.
+     */
+    executeNativeMongoQuery<T = any>(integrationId: IntegrationId, collectionName: string, aggregationPipeline: Array<any | undefined>): Promise<Array<T>>;
+    /**
+     * Executes a native Elasticsearch query against the given index and endpoint.
+     * See https://docs.getsquid.ai/docs/sdk/client-sdk/database/native-queries.
+     *
+     * @param integrationId  The id of the integration that the query is associated with.
+     * @param index          The Elasticsearch index to query.
+     * @param body           The raw request body to send (must be a valid ES query DSL object).
+     * @param endpoint       The Elasticsearch endpoint to call (default: "_search").
+     * @param method         The HTTP method to use (default: "GET").
+     * @returns             A promise that resolves with the result array.
+     */
+    executeNativeElasticQuery<T = any>(integrationId: IntegrationId, index: string, body: Record<string, any>, endpoint?: string, method?: 'GET' | 'POST'): Promise<Array<T>>;
+    /**
+     * Returns a set of AI specific clients.
+     */
+    ai(): AiClient;
+    /**
+     * Returns a set of functionality for interacting with jobs.
+     */
+    job(): JobClient;
+    /**
+     * Returns a set of functionality for interacting with API integrations.
+     */
+    api(): ApiClient;
+    /**
+     * Returns the AdminClient instance for performing administrative operations.
+     */
+    admin(): AdminClient;
+    /**
+     * Returns a set of functionality for interacting with the web.
+     */
+    web(): WebClient;
+    /**
+     * Returns a client for accessing file storage for the current app.
+     * Defaults to the built-in storage integration if none is provided.
+     *
+     * @param integrationId The storage integration ID (default is 'built_in_storage').
+     */
+    storage(integrationId?: IntegrationId): StorageClient;
+    /**
+     * Returns a client for managing external oauth tokens for integrations.
+     * Use this to save authorization codes and retrieve access tokens.
+     * Squid automatically handles token refresh when tokens expire.
+     *
+     * @param integrationId The integration ID
+     * @returns An ExternalAuthClient instance for the specified integration
+     */
+    externalAuth(integrationId: IntegrationId): ExternalAuthClient;
+    /**
+     * Returns a client for working with structured data extraction tools.
+     */
+    extraction(): ExtractionClient;
+    /**
+     * 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 options Optional configuration for the lock, including maxHoldTimeMillis to automatically release the lock
+     *   after a specified duration.
+     * @returns A promise that resolves with the lock object. The promise will reject if failed to acquire the lock.
+     */
+    acquireLock(mutex: string, options?: DistributedLockOptions): Promise<DistributedLock>;
+    /**
+     * Executes the given callback while holding a lock for the given mutex. The lock will be released when the callback
+     * finishes.
+     * @param mutex A string that uniquely identifies the lock.
+     * @param fn The callback to execute while holding the lock.
+     * @returns A promise that resolves with the result of the callback. The promise will reject if failed
+     *   to acquire the lock.
+     */
+    withLock<T>(mutex: string, fn: (lock: DistributedLock) => Promise<T>): Promise<T>;
+    /**
+     * Returns a queue manager for the given topic name and integration id. Using the queue manager you can consume and
+     * produce messages
+     */
+    queue<T>(topicName: string, integrationId?: IntegrationId): QueueManager<T>;
+    /**
+     * 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>;
+    /** Set to true if the client was destructured. */
+    get isDestructed(): boolean;
+    /** Provides information about the connection to the Squid Server. */
+    connectionDetails(): ConnectionDetails;
+    /** Returns the notification client for handling (publishing and receiving) custom messages. */
+    getNotificationClient(): NotificationClient;
+    private _validateNotDestructed;
+}