@squidcloud/client 1.0.342 → 1.0.344

package/dist/internal-common/src/public-types/document.public-types.d.ts

@@ -1,9 +1,11 @@
 import { IntegrationId } from './communication.public-types';
 /**
+ * Represents a primitive data type used in database fields.
  * @category Database
  */
 export type PrimitiveFieldType = string | number | boolean | null | Date;
 /**
+ * Represents a recursive field type structure for database documents, including primitives, arrays, and nested objects.
  * @category Database
  */
 export type FieldType = PrimitiveFieldType | Array<FieldType> | {
@@ -45,20 +47,25 @@ export type DocumentData = Record<FieldName, any | undefined>;
  */
 export type DocTimestamp = number;
 /**
- * The structure of a Squid Document.
+ * The structure of a Squid Document with metadata and dynamic fields.
  * @category Database
  */
 export interface SquidDocument {
+    /** The unique identifier of the document. */
     __docId__: DocId;
+    /** The timestamp of the document, typically in milliseconds. */
     __ts__: DocTimestamp;
     [fieldName: string]: FieldType | undefined;
 }
 /**
- * The full document id, including the collection name and the integration id.
+ * The full document identifier, combining collection name, document ID, and integration ID.
  * @category Database
  */
 export interface SquidDocIdObj {
+    /** The name of the collection containing the document. */
     collectionName: CollectionName;
+    /** The unique identifier of the document within the collection. */
     docId: DocId;
+    /** The ID of the integration associated with the document. */
     integrationId: IntegrationId;
 }

package/dist/internal-common/src/public-types/extraction.public-types.d.ts

@@ -3,43 +3,60 @@
  */
 export type DocumentFileDataType = 'image';
 /**
+ * Options for extracting data from a document file stored in the storage system.
  * @category Storage
  */
 export interface ExtractDataFromDocumentFileOptions {
+    /** An optional password required to access the document file, if encrypted. */
     password?: string;
 }
 /**
+ * Represents metadata for a file embedded within a document in the storage system.
  * @category Storage
  */
 export interface DocumentFileData {
+    /** The type of the embedded file (e.g., 'image'). */
     type: DocumentFileDataType;
+    /** The storage path of the file within the bucket. */
     pathInBucket: string;
 }
 /**
+ * Represents data for a single page within a document in the storage system.
  * @category Storage
  */
 export interface DocumentPageData {
+    /** An optional title for the page. */
     title?: string;
+    /** The text content extracted from the page. */
     text: string;
+    /** An array of file data objects embedded in the page. */
     fileDataList: DocumentFileData[];
 }
 /**
+ * Response structure for data extracted from a document in the storage system.
  * @category Storage
  */
 export interface ExtractDataFromDocumentResponse {
+    /** The storage path of the document within the bucket, if available. */
     documentPathInBucket?: string;
+    /** An array of page data extracted from the document. */
     pages: DocumentPageData[];
 }
 /**
+ * Represents text-only data for a single page in a document.
  * @category Storage
  */
 export interface TextOnlyPageData {
+    /** The text content of the page. */
     text: string;
+    /** An optional title for the page. */
     title?: string;
 }
 /**
+ * Response structure containing text-only data extracted from a document.
  * @category Storage
  */
 export interface DocumentTextDataResponse {
+    /** An array of text-only page data extracted from the document. */
     pages: TextOnlyPageData[];
 }

package/dist/internal-common/src/public-types/http-status.enum.d.ts

@@ -411,4 +411,5 @@ export declare const HttpStatus: {
      */
     readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
 };
+/** Union type of all defined HTTP status codes */
 export type HttpStatusCode = (typeof HttpStatus)[keyof typeof HttpStatus];

package/dist/internal-common/src/public-types/integration.public-types.d.ts

@@ -9,10 +9,15 @@ export declare const DATA_INTEGRATION_TYPES: readonly ["bigquery", "built_in_db"
  * @category Auth
  */
 export declare const AUTH_INTEGRATION_TYPES: readonly ["auth0", "jwt_rsa", "jwt_hmac", "cognito", "okta", "descope", "firebase_auth"];
+/** Supported integration types for GraphQL-based services. */
 export declare const GRAPHQL_INTEGRATION_TYPES: readonly ["graphql", "linear"];
+/** Supported integration types for HTTP-based services. */
 export declare const HTTP_INTEGRATION_TYPES: readonly ["api", "confluence"];
+/** Represents a supported integration type identifier, such as 'postgres', 'auth0', or 's3'. */
 export type IntegrationType = (typeof INTEGRATION_TYPES)[number];
+/** Supported schema types for integrations */
 export declare const INTEGRATION_SCHEMA_TYPES: readonly ["data", "api", "graphql"];
+/** Describes the type of schema the integration provides, such as data, API, or GraphQL schema. */
 export type IntegrationSchemaType = (typeof INTEGRATION_SCHEMA_TYPES)[number];
 /**
  * @category Database
@@ -24,13 +29,19 @@ export declare const BUILT_IN_DB_INTEGRATION_ID: IntegrationId;
 export declare const BUILT_IN_QUEUE_INTEGRATION_ID: IntegrationId;
 /**
  * ID for the cloud specific storage integration: s3 (built_in_s3) or gcs (built_in_gcs).
- * @category Storage
+ * @category
  */
 export declare const BUILT_IN_STORAGE_INTEGRATION_ID: IntegrationId;
+/** Metadata describing a configured integration, including its ID, type, timestamps, and optional configuration object. */
 export interface IntegrationInfo<ConfigurationType = Record<string, any> | undefined> {
+    /** The unique identifier of the integration instance. */
     id: IntegrationId;
+    /** The type of the integration (e.g., postgres, auth0, s3). */
     type: IntegrationType;
+    /** The date when the integration was created. */
     creationDate?: Date;
+    /** The date when the integration was last updated. */
     updateDate?: Date;
+    /** The configuration object for the integration, if any. */
     configuration: ConfigurationType;
 }

package/dist/internal-common/src/public-types/integrations/api.public-types.d.ts

@@ -1,14 +1,25 @@
 import { FieldName } from '../document.public-types';
+/** Represents the HTTP methods supported by an API endpoint. */
 export type HttpMethod = 'post' | 'get' | 'delete' | 'patch' | 'put';
+/** An identifier string used to uniquely represent an API endpoint. */
 export type ApiEndpointId = string;
+/** Represents the location in an API request where a parameter can be found. */
 export type ApiParameterLocation = 'query' | 'body' | 'header' | 'path';
+/** Represents the location in an API response where a value can appear. */
 export type ApiResponseParameterLocation = 'header' | 'body';
+/** Specifies the allowed locations where injection parameters can be inserted into the API request. */
 export type ApiInjectionParameterLocation = 'header' | 'query';
+/** A string path used to locate a specific field in a response structure. */
 export type FieldPath = string;
+/** A map of API endpoint definitions keyed by unique endpoint IDs. */
 export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
+/** Describes a field included in an API request, including its location, optional description, and whether it is required. */
 export interface ApiRequestField {
+    /** The location of the field in the API request (e.g., query, body, header, path). */
     location: ApiParameterLocation;
+    /** An optional description of the field's purpose or usage. */
     description?: string;
+    /** Indicates whether the field is mandatory for the request. */
     required?: boolean;
 }
 /** The options for calling an API. */
@@ -23,38 +34,67 @@ export interface CallApiOptions {
 }
 /** A native API call response. */
 export interface NativeApiCallResponse<BodyType = unknown> {
+    /** The response body, typed according to the expected content. */
     body: BodyType;
+    /** A record of HTTP headers returned in the response. */
     headers: Record<string, string>;
+    /** The HTTP status code of the response. */
     status: number;
 }
+/** Describes a field included in an API response, optionally including the field path and a description. */
 export interface ApiResponseField {
+    /** The location of the field in the API response (e.g., header, body). */
     location: ApiResponseParameterLocation;
+    /** The path to the field within the response structure, if applicable. */
     path?: FieldPath;
+    /** An optional description of the field's content or purpose. */
     description?: string;
 }
+/** Represents the possible values for injected field types used in request modification (e.g., secret or regular). */
 export declare const API_INJECTION_FIELD_TYPES: readonly ["secret", "regular"];
+/** The type of value to inject into an API request, such as a secret or a regular value. */
 export type ApiInjectionFieldType = (typeof API_INJECTION_FIELD_TYPES)[number];
+/** Defines a value to be injected into the API call, such as a secret or query parameter, along with its location and type. */
 export interface ApiInjectionField {
+    /** The value to be injected into the request. */
     value: string;
+    /** The type of the injected value, either 'secret' or 'regular'. */
     type: ApiInjectionFieldType;
+    /** The location in the request where the value should be injected (e.g., header, query). */
     location: ApiInjectionParameterLocation;
 }
+/** Connection options for interacting with a GraphQL API. */
 export interface GraphQLConnectionOptions {
+    /** The base URL of the GraphQL API endpoint. */
     baseUrl: string;
+    /** An optional schema defining fields to inject into the GraphQL request. */
     injectionSchema?: ApiInjectionSchema;
 }
+/** A mapping of field names to their corresponding injection field definitions. */
 export type ApiInjectionSchema = Record<FieldName, ApiInjectionField>;
+/** Options for discovering APIs via an OpenAPI specification. */
 export interface OpenApiDiscoveryOptions {
+    /** The URL of the OpenAPI specification document. */
     openApiSpecUrl: string;
 }
+/** Represents the structure of an API endpoint, including its path, method, schemas, and metadata. */
 export interface ApiEndpoint {
+    /** The relative path of the endpoint (e.g., '/users'). */
     relativePath: string;
+    /** The HTTP method used by the endpoint (e.g., 'get', 'post'). */
     method: HttpMethod;
+    /** A schema defining the fields expected in the request, if any. */
     requestSchema?: Record<FieldName, ApiRequestField>;
+    /** A schema defining the fields returned in the response, if any. */
     responseSchema?: Record<FieldPath, ApiResponseField>;
+    /** A schema defining fields to inject into the request, if any. */
     injectionSchema?: ApiInjectionSchema;
+    /** An optional array of tags categorizing the endpoint. */
     tags?: Array<string>;
+    /** An optional description of the endpoint's purpose or behavior. */
     description?: string;
+    /** The MIME type of the request body, if applicable (e.g., 'application/json'). */
     bodyMimeType?: string;
+    /** Indicates whether the request body is mandatory for the endpoint. */
     isRequestBodyRequired?: boolean;
 }

package/dist/internal-common/src/public-types/metric.public-types.d.ts

@@ -5,15 +5,21 @@
  * All Squid metrics starts with `squid_` prefix.
  */
 export declare const SQUID_METRIC_NAMES: readonly ["squid_functionExecution_count", "squid_functionExecution_time"];
+/** Name of a built-in Squid metric ('squid_functionExecution_count' or 'squid_functionExecution_time'). */
 export type SquidMetricName = (typeof SQUID_METRIC_NAMES)[number];
+/** Aggregation function used in metric queries (e.g., 'sum', 'max', 'median'). */
 export declare const METRIC_FUNCTIONS: readonly ["sum", "max", "min", "average", "median", "p95", "p99", "count"];
+/** Aggregation function used in metric queries (e.g., 'sum', 'max', 'median'). */
 export type MetricFunction = (typeof METRIC_FUNCTIONS)[number];
 /** Defines source of the metric: reported by user or automatically collected by the system (Squid). */
 export declare const METRIC_DOMAIN: readonly ["user", "squid"];
+/** Domain of the metric: 'user' for custom metrics, 'squid' for built-in system metrics. */
 export type MetricDomain = (typeof METRIC_DOMAIN)[number];
+/** Defines how to align data points in a metric query interval. */
 export declare const METRIC_INTERVAL_ALIGNMENT: readonly ["align-by-start-time", "align-by-end-time"];
 /** Indicates how to align per-point periods in metric queries. */
 export type MetricIntervalAlignment = (typeof METRIC_INTERVAL_ALIGNMENT)[number];
+/** Common parameters shared by all metric query requests. */
 export interface QueryMetricsRequestCommon {
     /** Kind of the metrics (domain) to query. */
     domain: MetricDomain;
@@ -80,16 +86,27 @@ export interface QueryMetricsRequestCommon {
      */
     noDataBehavior?: 'return-no-result-groups' | 'return-result-group-with-default-values';
 }
+/**
+ * Request structure for querying user-defined metrics.
+ * @category Metrics
+ */
 export interface QueryUserMetricsRequest<NameType extends string = string> extends QueryMetricsRequestCommon {
+    /** Specifies the user domain for custom metrics. */
     domain: 'user';
-    /** Squid metric name. */
+    /** Name of the user-defined metric to query. */
     name: NameType;
 }
+/**
+ * Request structure for querying built-in Squid metrics.
+ * @category Metrics
+ */
 export interface QuerySquidMetricsRequest<NameType extends SquidMetricName = SquidMetricName> extends QueryMetricsRequestCommon {
+    /** Specifies the squid domain for built-in system metrics. */
     domain: 'squid';
-    /** User metric name. */
+    /** Name of the built-in Squid metric to query. */
     name: NameType;
 }
+/** A request to query metrics, either Squid or user-defined, depending on the domain and metric name. */
 export type QueryMetricsRequest<NameType extends string = string> = QuerySquidMetricsRequest<NameType extends SquidMetricName ? NameType : SquidMetricName> | QueryUserMetricsRequest<NameType>;
 /**
  * Every result point is a list of [timestamp, values...],
@@ -98,11 +115,14 @@ export type QueryMetricsRequest<NameType extends string = string> = QuerySquidMe
  * The timestamp is always equal to the point period start date and is measured in Unix epoch seconds.
  */
 export type QueryMetricsResultPoint = [number, ...(number | null)[]];
+/** A group of metric results that share the same tag values. */
 export interface QueryMetricsResultGroup {
     /** Values of the tags in the group. The tags are ordered the same way as in request.groupByTags collection. */
     tagValues: string[];
+    /** List of result points for the group. */
     points: Array<QueryMetricsResultPoint>;
 }
+/** Common structure for metric query responses. */
 export interface QueryMetricsResponseCommon {
     /**
      * Result of the metrics query.
@@ -110,15 +130,25 @@ export interface QueryMetricsResponseCommon {
      */
     resultGroups: Array<QueryMetricsResultGroup>;
 }
+/**
+ * Response for a user-defined metric query.
+ * @category Metrics
+ */
 export interface QueryUserMetricsResponse<NameType extends string = string> extends QueryMetricsResponseCommon {
+    /** Specifies the user domain for custom metrics. */
     domain: 'user';
+    /** Name of the queried user-defined metric. */
     metricName: NameType;
 }
 /**
  * A single metric response for 'SquidMetricsRequest'.
+ * @category Metrics
  */
 export interface QuerySquidMetricsResponse<NameType extends SquidMetricName> extends QueryMetricsResponseCommon {
+    /** Specifies the squid domain for built-in system metrics. */
     domain: 'squid';
+    /** Name of the queried built-in Squid metric. */
     metricName: NameType;
 }
+/** Final normalized response for a metrics query, required fields guaranteed. */
 export type QueryMetricsResponse<NameType extends string = string> = Required<QuerySquidMetricsResponse<NameType extends SquidMetricName ? NameType : SquidMetricName> | QueryUserMetricsResponse<NameType>>;

package/dist/internal-common/src/public-types/openapi.public-types.d.ts

@@ -1,5 +1,9 @@
+/** Represents a standardized HTTP response in OpenAPI format. */
 export interface OpenApiResponse {
+    /** HTTP headers returned in the response. */
     headers: Record<string, any>;
+    /** Body content of the response. */
     body: any;
+    /** HTTP status code of the response. */
     statusCode: number;
 }

package/dist/internal-common/src/public-types/query.public-types.d.ts

@@ -6,14 +6,18 @@ import { Paths } from './typescript.public-types';
  */
 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.
+ * A join condition defining how two tables are related in a database query.
+ * The join conditions specify the alias for the left side of the join and the field names to join on.
  * @category Database
  */
 export interface JoinCondition {
+    /** The alias of the left table in the join operation. */
     leftAlias: Alias;
+    /** The field name from the left table to join on. */
     left: FieldName;
+    /** The field name from the right table to join on. */
     right: FieldName;
+    /** Indicates whether the join is an inner join (true) or outer join (false). */
     isInner: boolean;
 }
 /**
@@ -27,23 +31,27 @@ export type Condition<Doc extends DocumentData = any> = SimpleCondition<Doc> | C
  */
 export type Conditions<Doc extends DocumentData = any> = Array<Condition<Doc>>;
 /**
- * A single field query condition.
+ * A single field query condition for filtering database records.
  * @category Database
  */
 export interface SimpleCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>, MyOperator = Operator> {
+    /** The field name to apply the condition to. */
     fieldName: F;
+    /** The operator to use for comparing the field value. */
     operator: MyOperator;
+    /** The value to compare against the field. */
     value: any;
 }
 /**
- * A composite fields query condition.
+ * A composite fields query condition combining multiple simple conditions.
  * Just a list of simple conditions with specific set of operators. It should be
  * evaluated this way:
- * If A, B, C are the conditions and A` = A with '==' operator:
+ * If A, B, C are the conditions and A' = A with '==' operator:
  * A || (A' && B) || (A' && B' && C)
  * @category Database
  */
 export interface CompositeCondition<Doc extends DocumentData = any> {
+    /** An array of simple conditions with restricted operators for composite evaluation. */
     fields: Array<SimpleCondition<Doc, Paths<Doc>, CompositeConditionOperator>>;
 }
 type CompositeConditionOperator = '>=' | '<=' | '>' | '<';
@@ -63,26 +71,37 @@ export declare const ALL_OPERATORS: readonly ["in", "not in", "array_includes_so
  */
 export type Operator = (typeof ALL_OPERATORS)[number];
 /**
- * A definition of a sort by a field.
+ * A definition of a sort order by a field in a database query.
  * @category Database
  */
 export interface FieldSort<Doc> {
+    /** The name of the field to sort by. */
     fieldName: FieldName<Doc>;
+    /** Indicates whether the sort is ascending (true) or descending (false). */
     asc: boolean;
 }
 /**
- * A query object.
+ * A query object defining a database retrieval operation.
  * @category Database
  */
 export interface Query<Doc extends DocumentData = any> {
+    /** The full collection path such as "c1" or "c1/d1/c2". */
     collectionName: CollectionName;
+    /** The ID of the integration associated with the query. */
     integrationId: string;
+    /** An array of conditions to filter the query results. */
     conditions: Conditions<Doc>;
+    /** An array of field sort definitions to order the results. */
     sortOrder: Array<FieldSort<Doc>>;
+    /** The maximum number of records to return. */
     limit: number;
+    /** Optional configuration to limit results by specific fields with custom sorting. */
     limitBy?: {
+        /** The maximum number of records to return for this limit configuration. */
         limit: number;
+        /** The fields to apply the limit to. */
         fields: Array<FieldName<Doc>>;
+        /** Indicates whether to reverse the sort order for this limit. */
         reverseSort: boolean;
     };
 }

package/dist/internal-common/src/public-types/scheduler.public-types.d.ts

@@ -1,30 +1,43 @@
 import { ServiceFunctionName } from './backend.public-types';
 /**
+ * Configuration for a scheduled task in the platform.
  * @category Platform
  */
 export interface SchedulerConfig {
+    /** The name of the service function to be executed on the schedule. */
     functionName: ServiceFunctionName;
+    /** The cron expression defining the schedule timing. */
     cronExpression: string;
+    /** Indicates whether the scheduler should run exclusively, preventing overlaps. */
     exclusive: boolean;
 }
 /**
+ * Information about a scheduler instance in the platform.
  * @category Platform
  */
 export interface SchedulerInfo {
+    /** The unique identifier for the scheduler. */
     schedulerId: string;
+    /** The configuration details for the scheduler. */
     config: SchedulerConfig;
+    /** Indicates whether the scheduler is currently enabled. */
     enabled: boolean;
 }
 /**
+ * Options for updating an existing scheduler in the platform.
  * @category Platform
  */
 export interface UpdateSchedulerOptions {
+    /** The unique identifier of the scheduler to update. */
     schedulerId: string;
+    /** Optional flag to enable or disable the scheduler. */
     enabled?: boolean;
 }
 /**
+ * Request structure for updating multiple schedulers in the platform.
  * @category Platform
  */
 export interface UpdateSchedulersRequest {
+    /** An array of scheduler update options. */
     schedulers: UpdateSchedulerOptions[];
 }

package/dist/internal-common/src/public-types/schema.public-types.d.ts

@@ -20,8 +20,11 @@ type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
     /** Applies to the top level schema or a record in a nested object. */
     deletable?: boolean;
 };
+/** Extended JSON schema for a single property, supporting nested structures and Squid-specific metadata. */
 export type PropertySchema = ConvertDeep<JSONSchema>;
+/** Extended JSON schema for a top-level property, including database-related metadata. */
 export type TopLevelPropertySchema = PropertySchema & {
+    /** Marks the property as a primary key. */
     primaryKey?: boolean;
     /**
      * Whether the property is computed based on other properties or some formula.
@@ -44,6 +47,7 @@ export type TopLevelPropertySchema = PropertySchema & {
      */
     hidden?: boolean;
 };
+/** Schema for a full collection, allowing partial property definitions with extended metadata. */
 export type CollectionSchema = Omit<ConvertDeep<JSONSchema>, 'properties'> & {
     properties?: Record<string, TopLevelPropertySchema>;
 };

package/dist/internal-common/src/public-types/secret.public-types.d.ts

@@ -14,28 +14,38 @@ export type SecretKey = string;
  */
 export type SecretValue = string | number | boolean;
 /**
+ * Metadata for a secret, including its key and last updated timestamp.
  * @category Secret
  */
 export interface SecretMetadata {
+    /** The key identifying the secret. */
     key: SecretKey;
+    /** The timestamp (in milliseconds) when the secret was last updated. */
     lastUpdated: number;
 }
 /**
+ * A secret entry combining metadata with a typed value.
  * @category Secret
  */
 export interface SecretEntry<T extends SecretValue = SecretValue> extends SecretMetadata {
+    /** The value of the secret, constrained to the specified type. */
     value: T;
 }
 /**
+ * An API key entry combining metadata with a string value.
  * @category Secret
  */
 export interface ApiKeyEntry extends SecretMetadata {
+    /** The string value of the API key. */
     value: string;
 }
 /**
+ * A request structure for setting a secret with a key-value pair.
  * @category Secret
  */
 export interface SetSecretRequestEntry {
+    /** The key identifying the secret to set. */
     key: SecretKey;
+    /** The value to assign to the secret. */
     value: SecretValue;
 }

package/dist/internal-common/src/public-types/serialized-query.public-types.d.ts

@@ -1,36 +1,54 @@
 import { DocumentData } from './document.public-types';
 import { Alias, JoinCondition, Query } from './query.public-types';
 /**
+ * Represents a simple serialized query structure for database operations.
  * @category Database
  */
 export type SerializedSimpleQuery = {
+    /** Specifies that this is a simple query type. */
     type: 'simple';
+    /** The query object defining the database operation. */
     query: Query;
+    /** Indicates whether references should be dereferenced during query execution. */
     dereference: boolean;
 };
 /**
+ * Represents a serialized join query structure for database operations with multiple table relationships.
  * @category Database
  */
 export type SerializedJoinQuery = {
+    /** Specifies that this is a join query type. */
     type: 'join';
+    /** Specifies if the results should be grouped by the root alias. */
     grouped: boolean;
+    /** Indicates whether references should be dereferenced during query execution. */
     dereference: boolean;
+    /** The root table configuration for the join operation. */
     root: {
+        /** The alias for the root table in the join operation. */
         alias: Alias;
+        /** The query object defining the root table's operation. */
         query: Query;
     };
+    /** A mapping of aliases to their dependent aliases, defining the join order from left to right. */
     leftToRight: Record<Alias, Alias[]>;
+    /** A mapping of aliases to their corresponding queries for joined tables. */
     joins: Record<Alias, Query<DocumentData>>;
+    /** A mapping of aliases to their join conditions. */
     joinConditions: Record<Alias, JoinCondition>;
 };
 /**
+ * Represents a serialized merged query structure combining multiple queries for database operations.
  * @category Database
  */
 export type SerializedMergedQuery = {
+    /** Specifies that this is a merged query type. */
     type: 'merged';
+    /** An array of serialized queries to be merged. */
     queries: Array<SerializedQuery>;
 };
 /**
+ * A union type representing all possible serialized query structures for database operations.
  * @category Database
  */
 export type SerializedQuery = SerializedSimpleQuery | SerializedJoinQuery | SerializedMergedQuery;

package/dist/internal-common/src/public-types/socket.public-types.d.ts

@@ -1,3 +1,4 @@
+/** Squid client connection state. Can be 'CONNECTED', 'DISCONNECTED', or 'REMOVED'. */
 export declare const CLIENT_CONNECTION_STATES: readonly ["CONNECTED", "DISCONNECTED", "REMOVED"];
 /** Squid client connection state. */
 export type ClientConnectionState = (typeof CLIENT_CONNECTION_STATES)[number];

package/dist/internal-common/src/public-types/typescript.public-types.d.ts

@@ -1,12 +1,20 @@
+/** Makes the specified keys in a type optional, leaving the rest unchanged. */
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type PropertiesWithPrefix<Prefix extends string> = {
     [key in `${Prefix}${string}`]: any;
 };
 type Pred = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+/**
+ * Recursively flattens all keys of a type into dot notation paths up to a fixed depth.
+ * Used to map deeply nested fields with their access paths.
+ */
 export type DeepRecord<T, RemainingDepth extends number & keyof Pred = 5, Prefix extends string = ''> = RemainingDepth extends 0 ? PropertiesWithPrefix<Prefix> : {
     [k in keyof T]-?: k extends string | number ? Record<`${Prefix}${k}`, T[k]> | (Required<T>[k] extends any[] ? never : Required<T>[k] extends object ? DeepRecord<Required<T>[k], Pred[RemainingDepth], `${Prefix}${k}.`> : never) : never;
 }[keyof T];
+/** Gets the union of keys from a union of object types. */
 export type UnionKeys<T> = T extends any ? keyof T : never;
+/** Extracts the type of specific field `K` from a union of object types `T`. */
 export type FieldOf<T, K extends UnionKeys<T>> = Extract<T, Record<K, any>>[K];
+/** All possible deeply nested field paths of a type, joined by dot notation. */
 export type Paths<T> = UnionKeys<DeepRecord<T>>;
 export {};

package/dist/internal-common/src/public-types-backend/api-call.public-context.d.ts

@@ -12,10 +12,19 @@ export declare class ApiCallContext {
     readonly body: unknown;
     readonly options: ApiOptions;
 }
+/**
+ * Represents a request to call an API through a specified integration and endpoint.
+ * Includes optional method override and additional request options.
+ */
 export interface CallApiRequest<BodyType = any> {
+    /** The identifier of the integration through which the API is called. */
     integrationId: IntegrationId;
+    /** Target API endpoint to invoke. */
     endpointId: ApiEndpointId;
+    /** Optional request payload. */
     body?: BodyType;
+    /** Optional HTTP method override. Default is POST. */
     overrideMethod?: HttpMethod;
+    /** Additional request options. */
     options: ApiOptions;
 }