@squidcloud/client 1.0.435 → 1.0.436

package/dist/internal-common/src/metric-name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Names of the Squid metrics.
+ * Should be in sync with MetricName.kt.
+ * See MetricName.kt for documentation on each value.
+ */
+export declare const ALL_SQUID_METRIC_NAMES: readonly ["squid_functionExecution_count", "squid_functionExecution_time", "squid_aiChatbotContext_size", "squid_aiChatbotChatInputTokens_count", "squid_aiChatbotChatOutputTokens_count", "squid_aiChatbotChatOutcome_count", "squid_aiImageGeneration_count", "squid_aiImageGeneration_time", "squid_aiRemoveBackground_count", "squid_aiRemoveBackground_time", "squid_aiAudioTranscribe_count", "squid_aiAudioTranscribe_time", "squid_aiAudioCreateSpeech_count", "squid_aiAudioCreateSpeech_time", "squid_aiIntegrationData_count", "squid_aiIntegrationData_time", "squid_aiIntegrationApi_count", "squid_aiIntegrationApi_time", "squid_apiControllerCall_count", "squid_apiControllerCall_time", "squid_aiContextUpsert_count", "squid_aiContextDelete_count", "squid_codeInitialization_count", "squid_codeInitialization_time", "squid_deleteApiKey_count", "squid_deleteApiKey_time", "squid_deleteSecret_count", "squid_deleteSecret_time", "squid_discoverGraphQLConnectionSchema_count", "squid_discoverGraphQLConnectionSchema_time", "squid_discoverOpenApiSchema_count", "squid_discoverOpenApiSchema_time", "squid_discoverOpenApiSchemaFromFile_count", "squid_discoverOpenApiSchemaFromFile_time", "squid_executeBackendFunction_count", "squid_executeBackendFunction_time", "squid_getAiChatbotProfiles_count", "squid_getAiChatbotProfiles_time", "squid_getAllApiKeys_count", "squid_getAllApiKeys_time", "squid_getAllSecrets_count", "squid_getAllSecrets_time", "squid_getAppApiKey_count", "squid_getAppApiKey_time", "squid_getSecret_count", "squid_getSecret_time", "squid_graphql_count", "squid_graphql_time", "squid_graphqlQuery_count", "squid_graphqlQuery_time", "squid_integrationCount_value", "squid_acquireLock_count", "squid_releaseLock_count", "squid_mutate_count", "squid_mutate_time", "squid_metricQuery_count", "squid_metricQuery_time", "squid_metricReport_count", "squid_metricReport_time", "squid_nativeQuery_count", "squid_nativeQuery_time", "squid_openapi_count", "squid_openapi_time", "squid_produceTopicMessage_count", "squid_produceTopicMessage_time", "squid_query_count", "squid_query_time", "squid_registerQuery_count", "squid_registerQuery_time", "squid_rerankChunks_count", "squid_rerankChunks_time", "squid_schedulerJob_count", "squid_schedulerJob_time", "squid_schema_size", "squid_secrets_entries", "squid_storageDeleteFiles_count", "squid_storageDeleteFiles_time", "squid_storageGetDownloadUrl_count", "squid_storageGetDownloadUrl_time", "squid_storageGetFileMetadata_count", "squid_storageGetFileMetadata_time", "squid_storageListDirectoryContents_count", "squid_storageListDirectoryContents_time", "squid_storageUploadFile_count", "squid_storageUploadFile_time", "squid_subscribeToTopic_count", "squid_subscribeToTopic_time", "squid_testGraphQLConnection_count", "squid_testGraphQLConnection_time", "squid_testAgentProtocolConnection_count", "squid_testAgentProtocolConnection_time", "squid_trigger_count", "squid_trigger_time", "squid_upsertApiKey_count", "squid_upsertApiKey_time", "squid_upsertSecret_count", "squid_upsertSecret_time", "squid_vectorChunks_count", "squid_vectorChunks_time", "squid_webhook_count", "squid_webhook_time"];
+export type MetricName = (typeof ALL_SQUID_METRIC_NAMES)[number];
+/** Common prefix for all Squid metrics. */
+export declare const SQUID_METRIC_NAME_PREFIX = "squid_";

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

@@ -14,6 +14,10 @@ export interface AiAgentDatabaseIntegrationOptions {
     collectionsToUse?: string[];
     /** If true, disables the code interpreter when analyzing query results. Default: false. */
     disableCodeInterpreter?: boolean;
+    /** Disables the whole analyze stage (includes code interpreter). */
+    disableAnalyzeStage?: boolean;
+    /** Enables raw results in the response. */
+    enableRawResults?: boolean;
     /** If true, provides more detailed status updates during AI query execution. Default: false. */
     verboseStatusUpdates?: boolean;
     /** If provided, this agent will be used to generate the query. */

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

@@ -239,7 +239,14 @@ export interface AiFileUrl {
     /** The file name, can be used in the prompt to reference the file. */
     fileName?: string;
 }
-/** The purpose of the AI file, used to determine how the file should be processed or utilized. */
+/**
+ * The purpose of the AI file, used to determine how the file should be processed or utilized.
+ *
+ * - `'context'` - The file is included directly in the AI prompt as contextual content (e.g., images, PDFs).
+ *   Use this for files that the AI should reference when generating a response.
+ * - `'tools'` - The file is returned as part of a tool/function call result (e.g., query results, generated documents).
+ *   Use this for files produced by AI tools or integrations that should be delivered to the caller alongside the response.
+ */
 export type AiFilePurpose = 'context' | 'tools';
 /**
  * Metadata for an AI agent connected to an integration.
@@ -593,7 +600,7 @@ export interface AiStatusMessage {
     /** ID of the status update message. */
     messageId: string;
     /** The ID of the agent generating the status message. */
-    agentId: AiAgentId;
+    agentId?: AiAgentId;
     /** An optional chat ID associated with the status message. */
     chatId?: string;
     /** The title or summary of the status message. */

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

@@ -1,6 +1,7 @@
-import { AiChatOptions, AiSessionContext } from './ai-agent.public-types';
+import { AiAgentMemoryOptions, AiChatOptions, AiFileUrl, AiSessionContext } from './ai-agent.public-types';
 import { ApiOptions } from './api-client.public-types';
 import { AiAgentId, IntegrationId } from './communication.public-types';
+import { PartialBy } from './typescript.public-types';
 /**
  * Options for configuring AI query execution.
  * @category AI
@@ -13,16 +14,16 @@ export interface AiQueryOptions {
     instructions?: string;
     /** Whether to enable raw results output. */
     enableRawResults?: boolean;
-    /** Whether to generate a step-by-step walkthrough for the response. */
-    generateWalkthrough?: boolean;
     /** Options for the collection selection stage. */
     selectCollectionsOptions?: AiQuerySelectCollectionsOptions;
     /** Options for the query generation stage. */
     generateQueryOptions?: AiQueryGenerateQueryOptions;
-    /** Options specify how to query result should be analyzed (processed) before returning it to user. */
+    /** Options to specify how the query result should be analyzed (processed) before returning it to the user. */
     analyzeResultsOptions?: AiQueryAnalyzeResultsOptions;
     /** Session information for the AI query execution. */
-    sessionContext?: AiSessionContext;
+    sessionContext?: PartialBy<AiSessionContext, 'agentId'>;
+    /** memory options */
+    memoryOptions?: AiAgentMemoryOptions;
 }
 /**
  * Request to execute an AI query using a specific integration.
@@ -85,6 +86,12 @@ export interface AiQueryGenerateQueryOptions {
 }
 /** Options for the query result analysis. */
 export interface AiQueryAnalyzeResultsOptions {
+    /**
+     * When set to true, the stage is disabled.
+     * The response will contain generated queries, raw results, and a hardcoded text in the answer
+     * to check the result files.
+     */
+    disabled?: boolean;
     /** Enables or disables code interpreter mode. Default: 'false'. */
     enableCodeInterpreter?: boolean;
     /** Customizes AI agent behavior used by the stage. */
@@ -105,6 +112,8 @@ export interface ExecutedQueryInfo {
     purpose?: string;
     /** Whether this specific query executed successfully. */
     success: boolean;
+    /** Raw result file information. Undefined if upload failed or raw results are not enabled. */
+    rawResult?: AiFileUrl;
 }
 /**
  * Response from an AI query execution.
@@ -116,50 +125,26 @@ export interface AiQueryResponse {
     answer: string;
     /** Optional explanation for the AI-generated answer. */
     explanation?: string;
-    /** All executed queries with their details. */
-    executedQueries?: ExecutedQueryInfo[];
+    /** Executed queries with their details and raw result URLs. */
+    executedQueries: ExecutedQueryInfo[];
     /** Markdown format type of the executed query response. */
     queryMarkdownType?: string;
-    /** URL to access raw results from the query execution. */
+    /**
+     * @deprecated Use {@link ExecutedQueryInfo.rawResult} in {@link executedQueries} instead.
+     * URL to access raw results from the first executed query. Populated for backward compatibility.
+     */
     rawResultsUrl?: string;
     /** Indicates whether the query execution was successful. */
     success: boolean;
-    /** Indicates whether code interpreter was used to analyze the results. */
+    /** Indicates whether a code interpreter was used to analyze the results. */
     usedCodeInterpreter?: boolean;
     /**
      * When the AI needs clarification to generate a query, this field contains the clarification question.
-     * Only populated when `generateQueryOptions.allowClarification` is enabled and the AI determines
+     * Only populated when `generateQueryOptions.allowClarification` is enabled, and the AI determines
      * it cannot generate a valid query without more information.
      */
     clarificationQuestion?: string;
 }
-/**
- * Details of an executed query, including the query text and result type.
- * @category AI
- */
-export interface ExecutedQuery {
-    /** Text of the executed query. */
-    query: string;
-    /** The Markdown type of the result (sql, mongo, etc.). */
-    markdownType: string;
-    /** URL to access raw results from the query execution. */
-    rawResultsUrl?: string;
-}
-/**
- * Response from executing an AI query across multiple integrations.
- * Includes answers and explanations for each executed query.
- * @category AI
- */
-export interface ExecuteAiQueryMultiResponse {
-    /** AI-generated answer for the multi-integration query. */
-    answer: string;
-    /** Optional explanation for the AI-generated response. */
-    explanation?: string;
-    /** List of executed queries with details. */
-    executedQueries: Array<ExecutedQuery>;
-    /** Indicates whether the query execution was successful. */
-    success: boolean;
-}
 /**
  * The AI API call response
  * @category AI

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

@@ -1,6 +1,6 @@
 import { IntegrationId } from './communication.public-types';
 /** List of all integration types supported by Squid. */
-export declare const INTEGRATION_TYPES: readonly ["active_directory", "ai_agents", "ai_chatbot", "algolia", "alloydb", "api", "auth0", "bedrock", "azure_cosmosdb", "azure_postgresql", "azure_sql", "bigquery", "built_in_db", "built_in_gcs", "built_in_queue", "built_in_s3", "cassandra", "clickhouse", "cloudsql", "cockroach", "cognito", "connected_knowledgebases", "confluence", "confluent", "datadog", "db2", "descope", "documentdb", "dynamodb", "elasticsearch", "firebase_auth", "firestore", "gcs", "github", "google_calendar", "google_docs", "google_drive", "graphql", "hubspot", "jira", "jira_jsm", "jwt_hmac", "jwt_rsa", "kafka", "keycloak", "linear", "mariadb", "monday", "mongo", "mssql", "databricks", "mysql", "newrelic", "okta", "onedrive", "oracledb", "pinecone", "postgres", "redis", "s3", "salesforce_crm", "sap_hana", "sentry", "servicenow", "snowflake", "spanner", "xata", "zendesk", "freshdesk", "mail", "slack", "mcp", "a2a", "legend", "teams", "openai_compatible"];
+export declare const INTEGRATION_TYPES: readonly ["active_directory", "ai_agents", "ai_chatbot", "algolia", "alloydb", "api", "auth0", "bedrock", "azure_cosmosdb", "azure_postgresql", "azure_sql", "bigquery", "built_in_db", "built_in_gcs", "built_in_queue", "built_in_s3", "cassandra", "clickhouse", "cloudsql", "cockroach", "cognito", "connected_knowledgebases", "confluence", "confluent", "datadog", "db2", "descope", "documentdb", "dynamodb", "elasticsearch", "firebase_auth", "firestore", "gcs", "github", "google_calendar", "google_docs", "google_drive", "graphql", "hubspot", "jira", "jira_jsm", "jwt_hmac", "jwt_rsa", "kafka", "keycloak", "linear", "mariadb", "monday", "mongo", "mssql", "databricks", "mysql", "newrelic", "okta", "onedrive", "oracledb", "pinecone", "postgres", "redis", "s3", "salesforce_crm", "sap_hana", "sentry", "snowflake", "spanner", "xata", "zendesk", "servicenow_csm", "freshdesk", "mail", "slack", "mcp", "a2a", "legend", "teams", "openai_compatible"];
 /**
  * @category Database
  */

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

@@ -0,0 +1,30 @@
+import { ApiOptions } from '../public-types/api-client.public-types';
+import { ApiEndpointId, HttpMethod } from '../public-types/api.public-types';
+import { IntegrationId } from '../public-types/communication.public-types';
+/** The headers of an API call. */
+export type ApiHeaders = Record<string, string | number | boolean>;
+/** The context of an API call. */
+export declare class ApiCallContext {
+    readonly integrationId: IntegrationId;
+    readonly endpointId: ApiEndpointId;
+    readonly url: string;
+    readonly method: HttpMethod;
+    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;
+}

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

@@ -0,0 +1,148 @@
+import { SquidDocIdObj, SquidDocument } from '../public-types/document.public-types';
+import { Paths } from '../public-types/typescript.public-types';
+/**
+ * The mutation type.
+ * @category Database
+ */
+export declare const MUTATION_TYPES: readonly ["insert", "update", "delete"];
+/**
+ * @category Database
+ */
+export type MutationType = (typeof MUTATION_TYPES)[number];
+interface BaseMutation {
+    type: MutationType;
+    squidDocIdObj: SquidDocIdObj;
+}
+/**
+ * A mutation on a document.
+ * @category Database
+ */
+export type Mutation<T = any> = UpdateMutation<T> | InsertMutation<T> | DeleteMutation;
+/**
+ * Represents a delete mutation on a document.
+ * @category Database
+ */
+export interface DeleteMutation extends BaseMutation {
+    /** Specifies that the mutation is a deletion. */
+    type: 'delete';
+}
+/**
+ * Represents an update mutation on a document.
+ * @category Database
+ */
+export interface UpdateMutation<T = any> extends BaseMutation {
+    /** Specifies that the mutation is an update. */
+    type: 'update';
+    /** The updated properties */
+    properties: {
+        [key in keyof T & string]?: Array<PropertyMutation<T[key]>>;
+    };
+}
+/**
+ * Represents an insert mutation on a document.
+ * @category Database
+ */
+export interface InsertMutation<T = any> extends BaseMutation {
+    /** Specifies that the mutation is an insertion. */
+    type: 'insert';
+    /** The inserted document */
+    properties: T;
+}
+/**
+ * A representation of a single property update.
+ * @category Database
+ */
+export type PropertyMutation<Value = any> = ApplyNumericFnPropertyMutation | ApplyStringFnPropertyMutation | ValueUpdatePropertyMutation<Value> | RemovePropertyMutation;
+/**
+ * A value update property mutation.
+ * @category Database
+ */
+export interface ValueUpdatePropertyMutation<Value = any> {
+    /** Specifies that the mutation updates a value. */
+    type: 'update';
+    /** New value to be set. */
+    value: Value;
+}
+/**
+ * Applying a numeric function to a property.
+ * @category Database
+ */
+export interface ApplyNumericFnPropertyMutation {
+    /** Specifies that the mutation applies a numeric function. */
+    type: 'applyNumericFn';
+    /** Numeric function to apply. */
+    fn: 'increment';
+    /** Value to use in the numeric function. */
+    value: number;
+}
+/**
+ * A property update that removes a property from a document.
+ * @category Database
+ */
+export interface RemovePropertyMutation {
+    /** Specifies that the mutation removes a property. */
+    type: 'removeProperty';
+}
+interface ApplyExtendString {
+    /** Specifies that the mutation applies a string function. */
+    type: 'applyStringFn';
+    /** String function to extend the existing string. */
+    fn: 'extendString';
+    /** String value to append. */
+    value: string;
+}
+interface ApplyTrimString {
+    /** Specifies that the mutation applies a string function. */
+    type: 'applyStringFn';
+    /** String function to trim the existing string. */
+    fn: 'trim';
+}
+/**
+ * A property mutation that modifies a string.
+ * @category Database
+ */
+export type ApplyStringFnPropertyMutation = ApplyExtendString | ApplyTrimString;
+/**
+ * The before and after documents of a document change.
+ * @category Database
+ */
+export interface BeforeAndAfterDocs<T = SquidDocument> {
+    /** Document state before the mutation. */
+    before: T | undefined;
+    /** Document state after the mutation. */
+    after: T | undefined;
+}
+/**
+ * The mutation context that will be provided to the security function.
+ * @category Database
+ */
+export declare class MutationContext<T = any> {
+    readonly mutation: Mutation<T>;
+    readonly beforeAndAfterDocs: BeforeAndAfterDocs<T>;
+    readonly serverTimeStamp: Date;
+    /**
+     * Returns the state of the document before the mutation was applied.
+     */
+    get before(): T | undefined;
+    /**
+     * Returns the state of the document after the mutation was applied.
+     */
+    get after(): T | undefined;
+    /**
+     * Returns the type of the mutation (insert, update, or delete).
+     */
+    getMutationType(): MutationType;
+    /** Returns true if the mutation affects the provided path. */
+    affectsPath(path: Paths<T>): boolean;
+    /**
+     * Find all affected paths starting from a root path.
+     *
+     * @example
+     * doc before - { a: { b: 1, c: 2 }, d: 3 }
+     * doc after - { a: { b: 1, c: 3 }, d: 4 }
+     * doc.affectedPaths('a') // ['a.c']
+     */
+    affectedPaths(startingRoot?: Paths<T> | string): Array<Paths<T>>;
+    private checkPath;
+}
+export {};

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

@@ -0,0 +1,72 @@
+import { IntegrationId } from '../public-types/communication.public-types';
+/**
+ * Represents the type of native query request, either relational, elastic or MongoDB.
+ * @category Database
+ */
+export type NativeQueryRequestType = 'relational' | 'mongo' | 'elasticsearch' | 'pure';
+interface BaseNativeQueryContext {
+    /** Type of the native query request. */
+    type: NativeQueryRequestType;
+    /** Identifier for the integration. */
+    integrationId: IntegrationId;
+}
+/**
+ * Context for executing a relational database query.
+ * @category Database
+ */
+export interface RelationalNativeQueryContext extends BaseNativeQueryContext {
+    /** Specifies that the query is for a relational database. */
+    type: 'relational';
+    /** SQL query string to be executed. */
+    query: string;
+    /** Parameters to be used in the query. */
+    params: Record<string, any>;
+}
+/**
+ * Context for executing a MongoDB query.
+ * @category Database
+ */
+export interface MongoNativeQueryContext extends BaseNativeQueryContext {
+    /** Specifies that the query is for a Mongo database. */
+    type: 'mongo';
+    /** Name of the MongoDB collection to query. */
+    collectionName: string;
+    /** Array of aggregation pipeline stages. */
+    aggregationPipeline: Array<any | undefined>;
+}
+/**
+ * Context for executing an Elasticsearch query.
+ * @category Database
+ */
+export interface ElasticsearchNativeQueryContext {
+    /** Specifies that the query is for an Elasticsearch database. */
+    type: 'elasticsearch';
+    /** Elasticsearch index to query. */
+    index: string;
+    /** Elasticsearch query string. */
+    endpoint?: string;
+    /** HTTP method to use for the request. */
+    method?: 'GET' | 'POST';
+    /** Body of the request. */
+    body: Record<string, any>;
+    /** Headers to include in the request. */
+    integrationId: IntegrationId;
+}
+/**
+ * Context for executing a pure database query.
+ * @category Database
+ */
+export interface PureNativeQueryContext extends BaseNativeQueryContext {
+    /** Specifies that the query is for a relational database. */
+    type: 'pure';
+    /** SQL query string to be executed. */
+    query: string;
+    /** Parameters to be used in the query. */
+    params: Record<string, any>;
+}
+/**
+ * Union type representing either a relational or MongoDB native query context.
+ * @category Database
+ */
+export type NativeQueryContext = RelationalNativeQueryContext | MongoNativeQueryContext | ElasticsearchNativeQueryContext | PureNativeQueryContext;
+export {};

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

@@ -0,0 +1,177 @@
+import { AiQueryOptions } from '../public-types/ai-query.public-types';
+import { IntegrationId } from '../public-types/communication.public-types';
+import { CollectionName, DocumentData } from '../public-types/document.public-types';
+import { FieldSort, Operator, Query, SimpleCondition } from '../public-types/query.public-types';
+import { DeepRecord, FieldOf, PartialBy, Paths } from '../public-types/typescript.public-types';
+/**
+ * The information provided to the secureAiQuery function about the AI query being executed.
+ * @category AI
+ */
+export interface AiQueryContext {
+    /** The prompt provided for the AI query. */
+    prompt: string;
+    /** The options used for executing the AI query. */
+    options: AiQueryOptions;
+}
+/**
+ * Represents the Squid query context.
+ * Passed to methods that require query details, such as those annotated with the `@secureCollection` annotation.
+ * @category Database
+ */
+export declare class QueryContext<T extends DocumentData = any> {
+    readonly query: Query<T>;
+    /**
+     * The ID of the integration being queried.
+     */
+    get integrationId(): IntegrationId;
+    /**
+     * The name of the collection being queried.
+     */
+    get collectionName(): CollectionName;
+    /**
+     * The query limit if one exists, -1 otherwise.
+     */
+    get limit(): number;
+    /**
+     * Verifies that the query's sort order aligns with the provided field sorts. The fields specified in the `sorts`
+     * parameter must appear in the exact order at the beginning of the query's sort sequence. The query can include
+     * additional fields in its sort order, but only after the specified sorts.
+     *
+     * @param sorts An array of field sorts.
+     * @returns Whether the query's sorts matches the provided field sorts.
+     */
+    sortedBy(sorts: Array<PartialBy<FieldSort<T>, 'asc'>>): boolean;
+    /**
+     * Verifies that the query's sort order exactly matches the provided field sorts. The fields specified in the
+     * `sorts` parameter must appear in the exact order in the query's sort sequence. No additional sorts may be present
+     * in the query.
+     *
+     * @param sorts An array of field sorts.
+     * @returns Whether the query's sorts exactly match the provided field sorts.
+     */
+    sortedByExact(sorts: Array<PartialBy<FieldSort<T>, 'asc'>>): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified condition. A subquery is defined as a query that evaluates
+     * to a subset of the results that would be obtained by applying the parent condition. The subquery may also include
+     * additional conditions, as these only narrow the result set.
+     *
+     * @param fieldName The name of the field for the condition.
+     * @param operator The operator of the condition.
+     * @param value The value of the condition.
+     * @returns Whether the query is a subquery of the parent condition.
+     */
+    isSubqueryOf<F extends Paths<T>, O extends AllOperators>(fieldName: F, operator: O, value: GenericValue<T, F, O> | null): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified condition. A subquery is defined as a query that evaluates
+     * to a subset of the results that would be obtained by applying the parent condition. The subquery may also include
+     * additional conditions, as these only narrow the result set.
+     *
+     * @param condition The condition to validate.
+     * @returns Whether the query is a subquery of the parent condition.
+     */
+    isSubqueryOfCondition(condition: GeneralCondition<T>): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified conditions. A subquery is defined as a query that evaluates
+     * to a subset of the results that would be obtained by applying the parent conditions. The subquery may also include
+     * additional conditions, as these only narrow the result set.
+     *
+     * @param conditions The conditions to validate.
+     * @returns Whether the query includes subquery of the parent conditions.
+     */
+    isSubqueryOfConditions(conditions: GeneralConditions<T>): boolean;
+    /**
+     * Verifies that the query is a subquery of the specified query. A subquery is defined as a query that evaluates
+     * to a subset of the results that obtained for the parent query, including sorts and limits.
+     *
+     * @param query The query to validate.
+     * @returns Whether the query is a subquery of the parent query.
+     */
+    isSubqueryOfQuery(query: Query<T>): boolean;
+    /**
+     * Returns all conditions that apply to any of the specified field names. This method
+     * provides a convenient way to retrieve all conditions that involve a specific set of fields.
+     *
+     * @param fieldNames The field names for which to retrieve conditions.
+     * @returns An array of conditions that involve any of the specified field names.
+     */
+    getConditionsFor<K extends Paths<T>>(...fieldNames: Array<K>): ContextConditions<T, K>;
+    /**
+     * Returns all conditions that apply to the specified field name. This method provides
+     * a convenient way to retrieve all conditions that involve a specific field.
+     *
+     * @param fieldName The field name for which to retrieve conditions.
+     * @returns An array of conditions that involve the specified field name.
+     */
+    getConditionsForField<K extends Paths<T>>(fieldName: K): ContextConditions<T>;
+    /**
+     * Returns true if the given document can be a result of the query.
+     * The method does not account for limit and sort order.
+     */
+    documentMatchesQuery(doc: DocumentData): boolean;
+}
+/**
+ * A list of context conditions.
+ * @category Database
+ */
+export type ContextConditions<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = Array<ContextCondition<Doc, F>>;
+/**
+ * A Context condition - a condition that replaces multiple '==' or '!=' conditions with 'in' and 'not in'.
+ * @category Database
+ */
+export type ContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = InContextCondition<Doc, F> | NotInContextCondition<Doc, F> | OtherContextCondition<Doc, F>;
+/**
+ * A condition using the 'in' operator to match values within a set.
+ * @category Database
+ */
+export interface InContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, 'in'> {
+    /** Specifies the 'in' operator to check if a value exists within an array. */
+    operator: 'in';
+    /** An array of values to match against the field. */
+    value: Array<FieldOf<DeepRecord<Doc>, Paths<Doc>> | any>;
+}
+/**
+ * A condition using the 'not in' operator to exclude values within a set.
+ * @category Database
+ */
+export interface NotInContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, 'not in'> {
+    /** Specifies the 'not in' operator to check if a value does not exist within an array. */
+    operator: 'not in';
+    /** An array of values to exclude from the field. */
+    value: Array<FieldOf<DeepRecord<Doc>, Paths<Doc>> | any>;
+}
+/**
+ * A condition using operators other than 'in' or 'not in' for field comparisons.
+ * @category Database
+ */
+export interface OtherContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, Exclude<ContextOperator, 'in' | 'not in'>> {
+    /** The operator to use for the comparison, excluding 'in' and 'not in'. */
+    operator: Exclude<ContextOperator, 'in' | 'not in'>;
+    /** The value to compare against the field. */
+    value: FieldOf<DeepRecord<Doc>, Paths<Doc>> | any;
+}
+/**
+ * A condition that includes all operators, including 'in' and 'not in', for general use.
+ * @category Database
+ */
+export interface GeneralCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, AllOperators> {
+    /** The operator to apply to the condition, including all possible operators. */
+    operator: AllOperators;
+    /** The value to use in the condition comparison. */
+    value: any;
+}
+/**
+ * A list of general conditions.
+ * @category Database
+ */
+export type GeneralConditions<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = Array<GeneralCondition<Doc, F>>;
+/**
+ * @category Database
+ */
+export type ContextOperator = Exclude<Operator, '==' | '!='> | 'in' | 'not in';
+type AllOperators = Operator | 'in' | 'not in';
+/**
+ * A generic value that can exist in a query.
+ * @category Database
+ */
+export type GenericValue<Doc = any, F extends Paths<Doc> = Paths<Doc>, O extends AllOperators = any> = O extends 'in' ? Array<DeepRecord<Doc>[F]> | null : O extends 'not in' ? Array<DeepRecord<Doc>[F]> | null : DeepRecord<Doc>[F] | null;
+export {};