@squidcloud/client 1.0.486 → 1.0.488

package/dist/internal-common/src/ai/system-openai-compatible.d.ts

@@ -0,0 +1,35 @@
+/**
+ * System-level OpenAI-compatible backends ("slots") for Squid's own internal AI calls.
+ *
+ * Generic plumbing for pointing an internal model at ANY OpenAI-compatible HTTP endpoint —
+ * primarily Squid's own self-hosted models, but any OpenAI-compatible backend works. The
+ * non-secret part of a slot (base URL, optional headers/extra body) is hardcoded here on purpose
+ * (changing a backend is a reviewed code change); only the API key lives in Vault under
+ * `SystemSecrets['openai-compatible'][slotName].apiKey`.
+ *
+ * NOT the customer-facing `openai_compatible` Integration (per-app, console-configured). Models
+ * served through these slots are declared in `AI_CHAT_MODEL_REGISTRY` with
+ * `providerType: 'openai-compatible'` + `openAiCompatibleSlot`, and resolve only with
+ * `keyType: 'system'` (see `AiProviderFactory.getChatProviderForModel`) — never customer-reachable.
+ *
+ * No slots are defined yet (foundation only). To wire one up:
+ *   1. add a slot below, e.g. `'my-model': { baseUrl: 'https://llm.internal.squid/v1' }`;
+ *   2. seed its key in `SystemSecrets['openai-compatible']['my-model'].apiKey`;
+ *   3. add a model entry in ai-model.registry.ts pointing `openAiCompatibleSlot: 'my-model'`.
+ */
+/** Non-secret configuration of one system OpenAI-compatible backend. */
+export interface SystemOpenAiCompatibleSlotConfig {
+    /** Base URL of the OpenAI-compatible API, e.g. a self-hosted 'https://llm.internal.squid/v1'. */
+    baseUrl: string;
+    /** Extra HTTP headers sent with every request. */
+    headers?: Record<string, string>;
+    /** Extra JSON body fields merged into every request — reserved wire fields are dropped by the provider. */
+    extraBody?: Record<string, unknown>;
+}
+/** Name of a system OpenAI-compatible slot (a key of `SYSTEM_OPENAI_COMPATIBLE_SLOTS`). */
+export type SystemOpenAiCompatibleSlotName = string;
+/**
+ * Registered system OpenAI-compatible slots, keyed by name. Empty by design — add a self-hosted
+ * (or any other) OpenAI-compatible backend here; see the module doc above.
+ */
+export declare const SYSTEM_OPENAI_COMPATIBLE_SLOTS: Record<SystemOpenAiCompatibleSlotName, SystemOpenAiCompatibleSlotConfig>;

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

@@ -0,0 +1,14 @@
+/**
+ * Names of the Squid metrics.
+ *
+ * This list and its Kotlin counterpart (MetricName.kt) may diverge:
+ * each side declares only the metrics that its own backend emits.
+ * However, metrics emitted by both backends MUST use identical names on both sides —
+ * otherwise dashboards and metric queries that mix data from both sources will break.
+ *
+ * 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_aiChatbotChatReasoningTokens_count", "squid_aiChatbotChatCacheReadInputTokens_count", "squid_aiChatbotChatCacheWriteInputTokens_count", "squid_aiChatbotChatCostUsd_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_sourceCodeAnalysis_count", "squid_sourceCodeAnalysis_time", "squid_sourceCodeWorkspaceBytes_value", "squid_sourceCodeInputTokens_count", "squid_sourceCodeOutputTokens_count", "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_apiControllerCall_count", "squid_apiControllerCall_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_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_queueMessageHandler_count", "squid_queueMessageHandler_time", "squid_registerQuery_count", "squid_registerQuery_time", "squid_rerankChunks_count", "squid_rerankChunks_time", "squid_schedulerJob_count", "squid_schedulerJob_time", "squid_eventHandler_count", "squid_eventHandler_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", "squid_acquireLock_count", "squid_acquireLock_time", "squid_releaseLock_count", "squid_releaseLock_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.public-types.d.ts

@@ -505,6 +505,11 @@ export interface BaseAiChatOptions {
     temperature?: number;
     /** Preset instruction options that can be toggled on */
     guardrails?: GuardrailsOptions;
+    /**
+     * Refuses prompts that carry PII before they reach the model. Read from the stored agent only —
+     * a value passed with a chat request is ignored, so a caller cannot switch off its own screening.
+     */
+    pii?: AiPiiOptions;
     /** The LLM model to use. Can be a vendor model name (string) or an integration-based model (object). */
     model?: AiChatModelSelection;
     /** Which provider's reranker to use for reranking the context. Defaults to 'cohere'. */
@@ -1077,6 +1082,56 @@ export type GuardrailsOptions = {
     /** A custom guardrail instruction, if specified. */
     custom?: string;
 };
+/**
+ * PII kinds a prompt can be screened for. Each one is judged in context by the screening model, so
+ * a value is classified by what the prompt says it is rather than by which format it happens to fit.
+ * @category AI
+ */
+export type AiPiiEntityType = 'email' | 'phoneNumber' | 'creditCard' | 'ssn' | 'iban' | 'passport';
+/** Entity kinds screened when {@link AiPiiOptions.entities} is omitted. */
+export declare const DEFAULT_PII_ENTITY_TYPES: ReadonlyArray<AiPiiEntityType>;
+/** Model that screens prompts unless overridden. Small and fast: it runs on every prompt. */
+export declare const DEFAULT_PII_CLASSIFIER_MODEL = "gpt-5.6-luna";
+/**
+ * Rejects a prompt before it reaches the agent's model when it carries PII, so the prompt is never
+ * sent to the model provider, never answered, and never written to chat memory.
+ *
+ * Screening is one {@link classifierModel} call per prompt, covering {@link entities} and
+ * {@link customRules} together. Because a model does the reading rather than a pattern, a value is
+ * judged by what the prompt says it is, and app-specific identifiers can be described in plain
+ * language instead of expressed as a format.
+ *
+ * This is the inverse of {@link GuardrailsOptions.disablePii}, which asks the agent's own model not
+ * to *emit* PII in its answer.
+ * @category AI
+ */
+export type AiPiiOptions = {
+    /** `reject` refuses a prompt carrying PII; `off` (default) disables screening entirely. */
+    onDetect: 'off' | 'reject';
+    /** Entity kinds to screen for. Defaults to {@link DEFAULT_PII_ENTITY_TYPES}. */
+    entities?: Array<AiPiiEntityType>;
+    /** App-specific PII in plain language, e.g. `'internal case numbers like CASE-12345'`. */
+    customRules?: Array<string>;
+    /** Model performing the screening. Defaults to {@link DEFAULT_PII_CLASSIFIER_MODEL}. */
+    classifierModel?: AiChatModelSelection;
+    /** Literal values that never count as PII, e.g. a shared support address. */
+    allowList?: Array<string>;
+};
+/**
+ * Outcome of screening one prompt. On a detection the prompt is replaced by {@link redactedPrompt}
+ * everywhere it would otherwise be stored, so the audit trail records that a request was refused
+ * and why without restating the values that caused it.
+ * @category AI
+ */
+export type AiPiiScanResult = {
+    detected: false;
+} | {
+    detected: true;
+    /** Entity kinds and custom-rule names that matched. Never the matched values. */
+    matchedTypes: Array<string>;
+    /** The prompt with every match replaced by a `[REDACTED:<type>]` placeholder. */
+    redactedPrompt: string;
+};
 /**
  * Response structure for transcribing audio and asking an AI agent a question.
  * @category AI
@@ -1146,8 +1201,8 @@ export type AiSessionContext = {
     /** The ID of the job associated with the session. */
     jobId: JobId;
     /**
-     * The conversation this call belongs to, as the caller named it (`memoryOptions.memoryId`, or the
-     * deprecated `chatId`). Stable across the turns of one chat and different for two chats, including
+     * The conversation this call belongs to, as the caller named it (`memoryOptions.memoryId`).
+     * Stable across the turns of one chat and different for two chats, including
      * two chats of the same client, which `clientId` is not: a client id belongs to a connection, and
      * one connection can carry several conversations. Not the id chat history is keyed by — that one
      * falls back to `clientId` — so do not read it as one. Absent for callers that named no conversation

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

@@ -161,8 +161,9 @@ export interface AiKnowledgeBaseGraphSearchOptions {
 }
 /**
  * Per-knowledge-base GraphRAG configuration. Opt-in and mutable (unlike `embeddingModel`/`vectorDbType`);
- * only honored for `vectorDbType:'mongoAtlas'` KBs. Enabling it on a KB that already has content requires a
- * graph backfill (the `rebuildGraph` endpoint).
+ * only honored for `vectorDbType:'mongoAtlas'` KBs. Enabling it on a KB that already has content backfills
+ * the graph automatically (a debounced structural build runs once the KB goes quiet); the `rebuildGraph`
+ * endpoint remains available for an immediate or full rebuild.
  * @category AI
  */
 export interface AiKnowledgeBaseGraphConfig {
@@ -172,6 +173,12 @@ export interface AiKnowledgeBaseGraphConfig {
     extractionModel?: AiChatModelSelection;
     /** Optional domain taxonomy hint (entity types) injected into the extraction prompt. */
     entityTypes?: string[];
+    /**
+     * Quiet window (milliseconds) after the last graph activity before the sweep auto-builds the
+     * structure. Must be a positive integer. Defaults to the server's window (5 minutes); the sweep
+     * cadence (1 minute) bounds how promptly an elapsed window is picked up.
+     */
+    autoBuildDebounceMs?: number;
     /** Concept-layer (facet taxonomy) configuration. Omitted ⇒ `facets: 'auto'`. */
     concepts?: AiKnowledgeBaseGraphConceptsConfig;
 }
@@ -1085,6 +1092,13 @@ export interface GetKnowledgeBaseGraphStatusResponse {
      * {@link ingestUsage}.
      */
     combinedIngestUsage?: KnowledgeBaseGraphUsage;
+    /** When a structural/full rebuild last completed successfully (epoch millis), when one ever has. */
+    lastStructureBuildAt?: number;
+    /**
+     * When the debounced auto-build sweep will pick the KB up (epoch millis), present while an auto-build
+     * is pending. Recomputed per poll — it moves forward while ingest activity continues.
+     */
+    nextAutoBuildAt?: number;
 }
 /** The most recent graph backfill/rebuild job of a knowledge base. @category AI */
 export interface KnowledgeBaseGraphBuildJob {
@@ -1092,6 +1106,8 @@ export interface KnowledgeBaseGraphBuildJob {
     status: 'in_progress' | 'completed' | 'failed';
     /** Failure message, present when `status` is `'failed'`. */
     error?: string;
+    /** When the job was enqueued (epoch millis). */
+    startedAt?: number;
 }
 /**
  * Aggregated LLM token usage (and best-effort cost) of graph work on a KB. Token counts are the
@@ -1172,13 +1188,15 @@ export interface KnowledgeBaseGraphFacetValueStatus {
 /**
  * How much of the knowledge base's graph a rebuild recomputes.
  *
+ * - `'structural'` (default) — keeps the already-extracted entity graph (LLM extraction runs only for
+ *   contexts that were never graph-indexed, e.g. after an interrupted ingest) and recomputes the
+ *   derived structure on top of it: entity resolution, lexical mentions, topics and facets. Typically
+ *   a small fraction of a full rebuild's cost — the right choice for folding freshly ingested
+ *   documents into topics/facets.
  * - `'full'` — wipes the graph and re-extracts entities/relationships from every chunk with an LLM,
  *   then rebuilds the concept layer. The expensive deep-clean: re-extraction dominates its cost.
- * - `'structural'` — keeps the already-extracted entity graph (LLM extraction runs only for contexts
- *   that were never graph-indexed, e.g. after an interrupted ingest) and recomputes the derived
- *   structure on top of it: entity resolution, lexical mentions, topics and facets. Typically a small
- *   fraction of a full rebuild's cost — the right choice for folding freshly ingested documents into
- *   topics/facets.
+ *   Only needed when the extraction itself must be redone, e.g. after changing `entityTypes` or
+ *   `extractionModel`.
  * @category AI
  */
 export type KnowledgeBaseGraphRebuildMode = 'full' | 'structural';
@@ -1189,7 +1207,7 @@ export type KnowledgeBaseGraphRebuildMode = 'full' | 'structural';
 export interface RebuildKnowledgeBaseGraphRequest {
     /** The id of the AiKnowledgeBase. */
     knowledgeBaseId: AiKnowledgeBaseId;
-    /** What to recompute (see {@link KnowledgeBaseGraphRebuildMode}). Default `'full'`. */
+    /** What to recompute (see {@link KnowledgeBaseGraphRebuildMode}). Default `'structural'`. */
     mode?: KnowledgeBaseGraphRebuildMode;
 }
 /**

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,161 @@
+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];
+/**
+ * Base fields shared by all document mutations.
+ * @category Database
+ */
+export interface BaseMutation {
+    /** The type of the mutation. */
+    type: MutationType;
+    /** The identity of the mutated document. */
+    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';
+}
+/**
+ * A property mutation that appends a value to the existing string.
+ * @category Database
+ */
+export 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;
+}
+/**
+ * A property mutation that trims the existing string.
+ * @category Database
+ */
+export 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;
+}

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

@@ -0,0 +1,75 @@
+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';
+/**
+ * Base fields shared by all native query contexts.
+ * @category Database
+ */
+export 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;