@squidcloud/client 1.0.145 → 1.0.146-beta

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

@@ -1,14 +1 @@
-import { FieldType, Query, SquidDocId, SquidDocument } from '@squidcloud/common';
-export declare class DocumentStore {
-    private readonly squidDocIdToDoc;
-    saveDocument(squidDocId: SquidDocId, properties: SquidDocument | undefined): SquidDocument | undefined;
-    hasData(squidDocId: SquidDocId): boolean;
-    getDocument(squidDocId: SquidDocId): SquidDocument;
-    getDocumentOrUndefined(squidDocId: SquidDocId): SquidDocument | undefined;
-    compareValues(a: FieldType | undefined, b: FieldType | undefined): number;
-    compareSquidDocs(a: SquidDocument, b: SquidDocument, sortFieldNames: string[], sortOrders: ('asc' | 'desc')[]): number;
-    group(sortedDocs: SquidDocument[], sortFieldNames: string[]): SquidDocument[][];
-    sortAndLimitDocs(docIdSet: Set<SquidDocId>, query: Query): Array<SquidDocument>;
-    private removeInternalProperties;
-    migrateDocId(squidDocId: SquidDocId, newSquidDocId: SquidDocId): void;
-}
+export {};

package/dist/typescript-client/src/execute-function-options.d.ts

@@ -0,0 +1,73 @@
+/** Advanced options for a Squid `executeFunction` call. */
+export interface ExecuteFunctionOptions<ResultType> {
+    /** The name of the `@executable` function to invoke. */
+    functionName: string;
+    /** Optional caching configuration. Reuses results based on argument values. */
+    caching?: ExecuteFunctionCachingOptions<ResultType>;
+    /**
+     * Deduplication config for sharing results of concurrent calls with the same args.
+     * When set to true a default mode with 'compareArgsByReference' is used.
+     */
+    deduplication?: ConcurrentCallDeduplicationOptions | boolean;
+}
+/** Defines caching behavior for `executeFunction`. */
+export interface ExecuteFunctionCachingOptions<T> {
+    /** The caching implementation to use. */
+    cache: ExecuteFunctionCache<T>;
+}
+/** Interface for a function result cache. */
+export interface ExecuteFunctionCache<ValueType> {
+    /** Retrieves a cached value for the given arguments. */
+    get(args: Array<unknown>): ExecuteFunctionCacheLookupResult<ValueType>;
+    /** Caches a result for the given arguments. */
+    set(args: Array<unknown>, value: ValueType): void;
+}
+/** Result object returned from a cache lookup. */
+export type ExecuteFunctionCacheLookupResult<ValueType> = {
+    /** The cached value. */
+    value: ValueType;
+    /** Indicates that the value was found in the cache. */
+    found: true;
+} | {
+    /** Indicates that the value was not found in the cache. */
+    found: false;
+};
+/** Comparator function type for evaluating argument equality. */
+export type ExecuteFunctionArgsComparator = <T>(args1: Array<T>, args2: Array<T>) => boolean;
+/** Comparator that checks reference equality of arguments. */
+export declare const compareArgsByReference: ExecuteFunctionArgsComparator;
+/** Comparator that checks argument equality using serialization. */
+export declare const compareArgsBySerializedValue: ExecuteFunctionArgsComparator;
+/** A single cached result of a function call. */
+export interface ExecuteFunctionCachedResult<T> {
+    /** Arguments used for the function call. */
+    args: Array<unknown>;
+    /** The result value returned by the function. */
+    result: T;
+    /** Time (in ms) when the result was cached. */
+    cacheTimeMillis: number;
+}
+/** Options for `LastUsedValueExecuteFunctionCache`. */
+interface LastUsedValueExecuteFunctionCacheOptions {
+    /** Argument equality comparator. */
+    argsComparator: ExecuteFunctionArgsComparator;
+    /** Validity duration in milliseconds. */
+    valueExpirationMillis: number;
+}
+/** Lightweight cache storing only the last computed result. */
+export declare class LastUsedValueExecuteFunctionCache<T> implements ExecuteFunctionCache<T> {
+    private readonly options;
+    protected cachedEntry?: ExecuteFunctionCachedResult<T>;
+    /** Creates a new instance of `LastUsedValueExecuteFunctionCache`. */
+    constructor(options: Partial<LastUsedValueExecuteFunctionCacheOptions>);
+    /** @inheritdoc */
+    get(args: Array<unknown>): ExecuteFunctionCacheLookupResult<T>;
+    /** @inheritdoc */
+    set(args: Array<unknown>, value: T): void;
+}
+/** Configuration for deduplicating concurrent function calls. */
+export interface ConcurrentCallDeduplicationOptions {
+    /** Comparator to determine if concurrent calls are equivalent. */
+    argsComparator: ExecuteFunctionArgsComparator;
+}
+export {};

package/dist/typescript-client/src/external-auth-client.d.ts

@@ -0,0 +1,36 @@
+import { GetAccessTokenResponse } from '../../internal-common/src/public-types/external-auth/external-auth.public-types';
+/**
+ * Client for managing authentication tokens for external integrations.
+ *
+ * Provides methods for saving and retrieving auth tokens for external services.
+ * @category ExternalAuth
+ */
+export declare class ExternalAuthClient {
+    private readonly integrationId;
+    private readonly rpcManager;
+    /**
+     * Takes an auth token, potentially exchanges the auth token with an external api depending on the external auth,
+     * and stores the result in Squid's secure storage.
+     *
+     * This function requires Squid to be initialized with an API key
+     *
+     * @param authCode - The authorization code obtained from the auth provider's callback.
+     * @param identifier - A user-specific identifier (usually a user ID) to associate with the tokens.
+     *                     This allows multiple users to connect their own accounts to the same integration.
+     * @returns A promise that resolves with the access token and its expiration time.
+     */
+    saveAuthCode(authCode: string, identifier: string): Promise<GetAccessTokenResponse>;
+    /**
+     * Retrieves a valid access token for the integration.
+     * Automatically refreshes the token if it has expired or is about to expire.
+     *
+     * This function requires Squid to be initialized with an API key
+     *
+     * @param identifier - The user-specific identifier that was used when saving the auth code.
+     * @returns A promise that resolves with a valid access token and its expiration time.
+     *
+     * @throws Error if no tokens are found for the given integration and identifier.
+     *         The user must first complete the auth flow by calling `saveAuthCode()`.
+     */
+    getAccessToken(identifier: string): Promise<GetAccessTokenResponse>;
+}

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

@@ -0,0 +1,32 @@
+import { CreatePdfRequest, CreatePdfResponse, ExtractDataFromDocumentOptions, ExtractDataFromDocumentResponse } from '../../internal-common/src/public-types/extraction.public-types';
+/**
+ * ExtractionClient provides methods for extracting structured data
+ * from document files using AI-driven processing.
+ * @category Platform
+ */
+export declare class ExtractionClient {
+    private readonly rpcManager;
+    /**
+     * Extracts structured text data from a document file using AI.
+     *
+     * @param file - The document file to extract data from.
+     * @param options - (Optional) Extraction options such as parsing hints or preprocessing flags.
+     * @returns A promise that resolves with the extracted document data.
+     */
+    extractDataFromDocumentFile(file: File, options?: ExtractDataFromDocumentOptions): Promise<ExtractDataFromDocumentResponse>;
+    /**
+     * Extracts structured text data from a document at a remote URL using AI.
+     *
+     * @param url - The URL of the document to extract data from.
+     * @param options - (Optional) Extraction options such as parsing hints or preprocessing flags.
+     * @returns A promise that resolves with the extracted document data.
+     */
+    extractDataFromDocumentUrl(url: string, options?: ExtractDataFromDocumentOptions): Promise<ExtractDataFromDocumentResponse>;
+    /**
+     * Creates a PDF document from the provided request parameters.
+     * @param request - The request containing details for PDF creation, such as content or url.
+     * @return A promise that resolves with the response containing the URL of the created PDF. The url will expire after
+     *   1 hour.
+     */
+    createPdf(request: CreatePdfRequest): Promise<CreatePdfResponse>;
+}

package/dist/typescript-client/src/file-args-transformer.d.ts

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

package/dist/typescript-client/src/file-utils.d.ts

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

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

@@ -1,9 +1,63 @@
-export { CollectionReference } from './collection-reference';
-export { DocumentReference } from './document-reference';
-export { JoinQueryBuilder } from './query/join-query-builder.factory';
-export { Changes, QueryBuilder } from './query/query-builder.factory';
-export { deserializeQuery } from './query/deserializer';
-export { Squid, SquidOptions } from './squid';
-export { TransactionId } from './types';
-export { GraphQLClient } from './graphql-client';
-export { AiChatbotProfileReference } from './ai-chatbot-client';
+export * from './admin-client';
+export * from './agent/ai-agent-client';
+export * from './agent/ai-agent-client-reference';
+export * from './agent/ai-agent-client.types';
+export * from './ai-assistant-client';
+export * from './ai-audio-client';
+export * from './ai-client';
+export * from './ai-files-client';
+export * from './ai-image-client';
+export * from './ai-knowledge-base/ai-knowledge-base-client';
+export * from './ai-knowledge-base/ai-knowledge-base-client-reference';
+export * from './ai-matchmaking-client';
+export * from './api-client';
+export * from './auth.manager';
+export * from './backend-function.manager';
+export * from './client-customization.utils';
+export * from './client-id.service';
+export * from './collection-reference';
+export * from './collection-reference.factory';
+export * from './connection-details';
+export * from './console-utils';
+export * from './data.manager';
+export * from './destruct.manager';
+export * from './distributed-lock.manager';
+export * from './document-identity.service';
+export * from './document-reference';
+export * from './document-reference.factory';
+export * from './document-store';
+export * from './execute-function-options';
+export * from './external-auth-client';
+export * from './extraction-client';
+export * from './file-args-transformer';
+export * from './file-utils';
+export * from './integration-client';
+export * from './job-client';
+export * from './mutation/mutation-sender';
+export * from './native-query-manager';
+export * from './notification-client';
+export * from './observability-client';
+export * from './public-types';
+export * from './public-utils';
+export * from './query-utils';
+export * from './query/deserializer';
+export * from './query/join-query-builder.factory';
+export * from './query/local-query-manager';
+export * from './query/pagination';
+export * from './query/query-builder.factory';
+export * from './query/query-sender';
+export * from './query/query-subscription.manager';
+export * from './query/query.types';
+export * from './query/snapshot-emitter';
+export * from './queue.manager';
+export * from './rate-limiter';
+export * from './rpc.manager';
+export * from './scheduler-client';
+export * from './secret.client';
+export * from './socket.manager';
+export * from './squid';
+export * from './squid-http-client';
+export * from './storage-client';
+export * from './types';
+export * from './web-client';
+export * from './webhook.manager';

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

@@ -0,0 +1,60 @@
+import { IntegrationId, IntegrationInfo, IntegrationType } from './public-types';
+/**
+ * IntegrationClient manages integrations within an application,
+ * providing methods for listing, retrieving, updating, and deleting integrations.
+ * @category Platform
+ */
+export declare class IntegrationClient {
+    private readonly rpcManager;
+    private readonly iacBaseUrl;
+    /**
+     * Lists all integrations for the current application.
+     *
+     * @param type - (Optional) Filter by integration type.
+     * @returns A promise that resolves with a list of integrations.
+     */
+    list<ConfigurationType = Record<string, any>>(type?: IntegrationType): Promise<Array<IntegrationInfo<ConfigurationType>>>;
+    /**
+     * Retrieves the integration by its ID.
+     *
+     * @param integrationId - The ID of the integration to retrieve.
+     * @returns A promise that resolves with the integration info, or `undefined` if not found.
+     */
+    get<ConfigurationType = Record<string, any>>(integrationId: IntegrationId): Promise<IntegrationInfo<ConfigurationType> | undefined>;
+    /**
+     * Retrieves the integration's schema by its ID.
+     *
+     * @param integrationId - The ID of the integration to retrieve.
+     * @returns A promise that resolves with the integration schema, or `undefined` if not found.
+     */
+    getIntegrationSchema<SchemaType = Record<string, any>>(integrationId: IntegrationId): Promise<SchemaType | undefined>;
+    /**
+     * Sets the integration's schema by its ID.
+     *
+     * @param integrationId - The ID of the integration to update.
+     * @param schema - The schema to set for the integration.
+     * @returns A promise that resolves when the schema has been updated.
+     */
+    setIntegrationSchema<SchemaType = Record<string, any>>(integrationId: IntegrationId, schema: SchemaType): Promise<void>;
+    /**
+     * Deletes the integration with the given ID.
+     *
+     * @param integrationId - The ID of the integration to delete.
+     * @returns A promise that resolves when the integration has been deleted.
+     */
+    delete(integrationId: IntegrationId): Promise<void>;
+    /**
+     * Deletes multiple integrations by their IDs.
+     *
+     * @param integrationIds - An array of integration IDs to delete.
+     * @returns A promise that resolves when all deletions are complete.
+     */
+    deleteMany(integrationIds: Array<IntegrationId>): Promise<void>;
+    /**
+     * Creates or updates an integration.
+     *
+     * @param integration - The integration information to upsert.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    upsertIntegration<ConfigurationType = Record<string, any>>(integration: IntegrationInfo<ConfigurationType>): Promise<void>;
+}

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

@@ -0,0 +1,32 @@
+import { AsyncJob, JobId } from '../../internal-common/src/public-types/job.public-types';
+/**
+ * Handles job subscriptions and notifications.
+ *
+ * **Important:** Each `jobId` must be globally unique and kept private.
+ * Anyone who knows a job’s ID can query its status or result.
+ */
+export declare class JobClient {
+    private readonly socketManager;
+    private readonly rpcManager;
+    private readonly clientIdService;
+    private isListening;
+    private readonly listeners;
+    /**
+     * Retrieves the current status (and, if completed, the result) of a job.
+     *
+     * @param jobId A unique, private identifier for the job.
+     *              Do **not** reuse a `jobId` across clients—possessing the ID
+     *              allows anyone to inspect the job’s state.
+     */
+    getJob<T = any>(jobId: JobId): Promise<AsyncJob<T> | undefined>;
+    /**
+     * Waits until the specified job finishes, then resolves with its result or
+     * throws if the job fails.
+     *
+     * @param jobId A unique, private identifier for the job.
+     *              Do **not** reuse a `jobId` across clients—possessing the ID
+     *              allows anyone to inspect the job’s state.
+     */
+    awaitJob<T = any>(jobId: JobId): Promise<T>;
+    private maybeListenToJobs;
+}

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

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

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

@@ -1,7 +1 @@
-import { IntegrationId, NativeQueryRequest } from '@squidcloud/common';
-import { RpcManager } from './rpc.manager';
-export declare class NativeQueryManager {
-    private readonly rpcManager;
-    constructor(rpcManager: RpcManager);
-    executeNativeQuery<T>(integrationId: IntegrationId, request: NativeQueryRequest): Promise<T>;
-}
+export {};

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

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { ClientId } from '../../internal-common/src/public-types/communication.public-types';
+/**
+ * NotificationClient is a client for handling user-defined notifications.
+ * Using this class you can receive messages that are sent from the server to this client or
+ * publish messages to other clients. In order to publish a message you have to initialize the squid sdk with a valid
+ * api key.
+ */
+export declare class NotificationClient {
+    private readonly socketManager;
+    private readonly rpcManager;
+    /**
+     * Observes user-defined notifications.
+     */
+    observeNotifications(): Observable<unknown>;
+    /**
+     * Publishes a notification to clients.
+     */
+    publishNotification(payload: unknown, clientIds: Array<ClientId>): Promise<void>;
+}

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

@@ -0,0 +1,43 @@
+import { QueryMetricsRequest, QueryMetricsResponse } from '../../internal-common/src/public-types/metric.public-types';
+/**
+ * A client for reporting user metrics and querying both application-related Squid and user metrics.
+ * @category Platform
+ */
+export declare class ObservabilityClient {
+    private readonly rpcManager;
+    private pendingPromises;
+    private isReporting;
+    /**
+     * Reports metrics to the metric submission queue.
+     * The metric can be sent immediately or with some (several seconds) delay
+     * due to optimizations applied by Squid client.
+     * If no tags are provided tags are set to an empty record ({}).
+     * If no timestamp is provided the timestamp is set to now().
+     */
+    reportMetric<MetricNameType = string>(metric: MetricReport<MetricNameType>): void;
+    /**
+     * Flushes all pending (unsent) metrics.
+     * Note: Even after flushing, it may take some time for these metrics to become visible via 'queryMetrics' due to the
+     * eventual consistency of the metrics storage.
+     */
+    flush(): Promise<void>;
+    /** Queries a batch of metric values. */
+    queryMetrics<MetricName extends string = string>(metricRequest: QueryMetricsRequest<MetricName>): Promise<QueryMetricsResponse<MetricName>>;
+}
+/** A single metric event. */
+export interface Metric<MetricNameType = string> {
+    /** Name of the metric. */
+    name: MetricNameType;
+    /** Value of the metric. */
+    value: number;
+    /** Time associated with the metric. Milliseconds since UNIX epoch. */
+    timestamp: number;
+    /** Set of tags for the metric. */
+    tags: Record<string, string>;
+}
+/**
+ * MetricReport represents a single metric event with some optional fields.
+ * These optional fields are automatically populated by Squid with default values.
+ * @category Platform
+ */
+export type MetricReport<MetricNameType = string> = Omit<Metric<MetricNameType>, 'tags' | 'timestamp'> & Partial<Pick<Metric, 'tags' | 'timestamp'>>;

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

@@ -0,0 +1,30 @@
+export * from '../../internal-common/src/public-types/ai-agent-integrations.public-types';
+export * from '../../internal-common/src/public-types/ai-agent.public-types';
+export * from '../../internal-common/src/public-types/ai-assistant.public-types';
+export * from '../../internal-common/src/public-types/ai-common.public-types';
+export * from '../../internal-common/src/public-types/ai-knowledge-base.public-types';
+export * from '../../internal-common/src/public-types/ai-matchmaking.public-types';
+export * from '../../internal-common/src/public-types/ai-query.public-types';
+export * from '../../internal-common/src/public-types/api-client.public-types';
+export * from '../../internal-common/src/public-types/api.public-types';
+export * from '../../internal-common/src/public-types/backend.public-types';
+export * from '../../internal-common/src/public-types/code-executor.public-types';
+export * from '../../internal-common/src/public-types/communication.public-types';
+export * from '../../internal-common/src/public-types/context.public-types';
+export * from '../../internal-common/src/public-types/document.public-types';
+export * from '../../internal-common/src/public-types/external-auth/external-auth.public-types';
+export * from '../../internal-common/src/public-types/extraction.public-types';
+export * from '../../internal-common/src/public-types/http-status.public-types';
+export * from '../../internal-common/src/public-types/integration.public-types';
+export * from '../../internal-common/src/public-types/job.public-types';
+export * from '../../internal-common/src/public-types/metric.public-types';
+export * from '../../internal-common/src/public-types/openapi.public-types';
+export * from '../../internal-common/src/public-types/query.public-types';
+export * from '../../internal-common/src/public-types/regions.public-types';
+export * from '../../internal-common/src/public-types/scheduler.public-types';
+export * from '../../internal-common/src/public-types/schema.public-types';
+export * from '../../internal-common/src/public-types/secret.public-types';
+export * from '../../internal-common/src/public-types/serialized-query.public-types';
+export * from '../../internal-common/src/public-types/socket.public-types';
+export * from '../../internal-common/src/public-types/typescript.public-types';
+export * from '../../internal-common/src/public-types/web.public-types';

package/dist/typescript-client/src/public-utils.d.ts

@@ -0,0 +1 @@
+export * from '../../internal-common/src/public-utils/id-utils';

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

@@ -1,3 +1,10 @@
-import { SerializedQuery, SnapshotEmitter } from '@squidcloud/common';
-import { Squid } from '../squid';
-export declare function deserializeQuery<ReturnType = any>(squid: Squid, serializedQuery: SerializedQuery): SnapshotEmitter<ReturnType>;
+import { SerializedQuery } from '../public-types';
+import { Squid } from '../squid';
+import { SnapshotEmitter } from './snapshot-emitter';
+/**
+ * Deserialize a serialized query into a snapshot emitter.
+ * @param squid - The Squid instance.
+ * @param serializedQuery - The serialized query.
+ * @category Database
+ */
+export declare function deserializeQuery<ReturnType = any>(squid: Squid, serializedQuery: SerializedQuery): SnapshotEmitter<ReturnType>;