@squidcloud/client 1.0.482 → 1.0.484

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

@@ -0,0 +1,40 @@
+/**
+ * Options for starting a new LangGraph run.
+ * @category AI
+ */
+export interface InvokeLangGraphOptions {
+    /** If provided, the run executes against this thread. If omitted, a new thread is created. */
+    threadId?: string;
+    /** Initial state for the run. */
+    input?: Record<string, unknown>;
+}
+/**
+ * Successful result of a LangGraph invocation.
+ * @category AI
+ */
+export interface InvokeLangGraphSuccessResult {
+    /** Always `true` on success. */
+    ok: true;
+    /** Thread the run executed against. */
+    threadId: string;
+    /** `completed` when the graph finished, `interrupted` when awaiting a resume. */
+    status: 'completed' | 'interrupted';
+    /** Final (or paused) state values. */
+    state: Record<string, unknown> | null;
+    /** Next nodes to execute. Empty when `status` is `completed`. */
+    next: string[];
+}
+/**
+ * Successful result of a getState call.
+ * @category AI
+ */
+export interface GetLangGraphStateSuccessResult {
+    /** Always `true` on success. */
+    ok: true;
+    /** Thread the state belongs to. */
+    threadId: string;
+    /** Current state values. */
+    state: Record<string, unknown> | null;
+    /** Next nodes to execute. Empty if the graph has completed. */
+    next: string[];
+}

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

@@ -0,0 +1,191 @@
+import type { IntegrationInfo } from './integration.public-types';
+/** Identifies the source-code analysis AI function. */
+export declare const SOURCE_CODE_ANALYZE_FUNCTION_ID = "analyzeCode";
+/** Limits the number of repositories selected for analysis. */
+export declare const SOURCE_CODE_MAX_REPOSITORIES = 20;
+/** Limits each supplemental instruction field supplied to source-code analysis. */
+export declare const SOURCE_CODE_MAX_SUPPLEMENTAL_INSTRUCTIONS_LENGTH = 20000;
+/** Lists CLI providers available for source-code analysis. */
+export declare const SOURCE_CODE_ANALYZER_MODELS: readonly ["claude-code", "codex"];
+/** Identifies a CLI provider available for source-code analysis. */
+export type SourceCodeAnalyzerModel = (typeof SOURCE_CODE_ANALYZER_MODELS)[number];
+/** Lists supported source-control providers. */
+export declare const SOURCE_CONTROL_PROVIDERS: readonly ["github", "bitbucket"];
+/** Identifies a supported source-control provider. */
+export type SourceControlProvider = (typeof SOURCE_CONTROL_PROVIDERS)[number];
+/** Lists integration types that provide source repositories. */
+export declare const SOURCE_CODE_INTEGRATION_TYPES: readonly ["github", "bitbucket"];
+/** Identifies an integration type that provides source repositories. */
+export type SourceCodeIntegrationType = (typeof SOURCE_CODE_INTEGRATION_TYPES)[number];
+/** Configures source-code analysis for an AI agent integration. */
+export interface AiAgentSourceCodeIntegrationOptions {
+    /** Enables repository-backed code analysis. */
+    codeAnalysisEnabled: boolean;
+    /** Selects the CLI provider used for code analysis. */
+    analyzerModel?: SourceCodeAnalyzerModel;
+    /** Provides supplemental code-analysis instructions. */
+    analyzerInstructions?: string;
+}
+/** Stores the immutable GitHub identity and access metadata for a selected repository. */
+export interface GitHubRepositoryConfiguration {
+    /** Stores GitHub's numeric repository identifier. */
+    id: number;
+    /** Stores the owner/repository name. */
+    fullName: string;
+    /** Stores the credential-free HTTPS clone URL. */
+    cloneUrl: string;
+    /** Stores the credential-free HTTPS web URL. */
+    htmlUrl: string;
+    /** Stores the default branch name. */
+    defaultBranch: string;
+}
+/** Stores the immutable Bitbucket identity and access metadata for a selected repository. */
+export interface BitbucketRepositoryConfiguration {
+    /** Stores Bitbucket's immutable repository UUID. */
+    uuid: string;
+    /** Stores the workspace/repository name. */
+    fullName: string;
+    /** Stores the credential-free HTTPS clone URL. */
+    cloneUrl: string;
+    /** Stores the credential-free HTTPS web URL. */
+    webUrl: string;
+    /** Stores the default branch name. */
+    defaultBranch: string;
+}
+/** Represents the repository-selection portion of a GitHub integration configuration. */
+interface GitHubRepositorySelectionConfiguration {
+    /** Stores the legacy owner/repository selection. */
+    repository?: string;
+    /** Stores canonical selected repository metadata. */
+    repositories?: GitHubRepositoryConfiguration[];
+    /** Stores the selected default owner/repository name. */
+    defaultRepository?: string;
+}
+/** Represents the repository-selection portion of a Bitbucket integration configuration. */
+interface BitbucketRepositorySelectionConfiguration {
+    /** Stores the configured Bitbucket workspace slug. */
+    workspace: string;
+    /** Stores canonical selected repository metadata. */
+    repositories: BitbucketRepositoryConfiguration[];
+    /** Stores the selected default workspace/repository name. */
+    defaultRepository: string;
+}
+/** Describes a source repository that can be prepared for analysis. */
+export interface SourceRepository {
+    /** Identifies the source-control provider. */
+    provider: SourceControlProvider;
+    /** Stores the provider's immutable repository identifier. */
+    providerRepositoryId: string;
+    /** Stores the owner/repository name. */
+    fullName: string;
+    /** Stores the credential-free clone URL. */
+    cloneUrl: string;
+    /** Stores the repository web URL. */
+    webUrl: string;
+    /** Stores the repository's default branch. */
+    defaultBranch: string;
+}
+/** Requests analysis of selected source-code repositories. */
+export interface AnalyzeCodeRequest {
+    /** Contains the question to answer. */
+    question: string;
+    /** Narrows repository selection. */
+    repositoryHints?: string;
+    /** Narrows analysis to a captured reference. */
+    refHint?: string;
+    /** Supplies customer context for the answer. */
+    customerContext?: string;
+}
+/** Marks an inclusive range of lines in a repository path. */
+export interface SourceCodeLineRange {
+    /** Stores the first included line number. */
+    start: number;
+    /** Stores the last included line number. */
+    end: number;
+}
+/** Identifies a path supporting a source-code finding. */
+export interface SourceCodePathEvidence {
+    /** Stores the path relative to the repository root. */
+    path: string;
+    /** Marks the supporting line range when available. */
+    lines?: SourceCodeLineRange;
+}
+/** Identifies the captured repository reference behind a finding. */
+export interface SourceCodeRef {
+    /** Identifies the reference kind. */
+    type: 'branch' | 'tag' | 'commit';
+    /** Stores the captured reference name. */
+    name: string;
+}
+/** Records repository evidence supporting a source-code answer. */
+export interface SourceCodeRepositoryEvidence {
+    /** Stores the owner/repository name. */
+    repository: string;
+    /** Identifies the inspected captured reference. */
+    ref: SourceCodeRef;
+    /** Stores the immutable commit SHA. */
+    commitSha: string;
+    /** Lists paths supporting the finding. */
+    paths: SourceCodePathEvidence[];
+    /** Stores the snapshot fetch time. */
+    fetchedAt: string;
+    /** Marks evidence from a stale snapshot. */
+    stale: boolean;
+}
+/** Returns a source-code analysis answer and its evidence. */
+export interface AnalyzeCodeResult {
+    /** Contains the concise answer. */
+    answer: string;
+    /** Lists repository evidence supporting the answer. */
+    repositories: SourceCodeRepositoryEvidence[];
+    /** Stores the latest snapshot fetch time. */
+    fetchTimestamp: string;
+    /** Marks whether any source snapshot is stale. */
+    stale: boolean;
+    /** Lists warnings encountered during analysis. */
+    warnings: string[];
+    /** Warns when a prepared workspace cannot persist. */
+    workspacePersistenceWarning?: string;
+}
+/** Requests discovery from an existing or draft source-code integration. */
+export type DiscoverSourceRepositoriesRequest = {
+    /** Identifies the source-code integration type. */
+    integrationType: SourceCodeIntegrationType;
+    /** Identifies the persisted integration. */
+    integrationId: string;
+    /** Prevents draft and persisted integration inputs from mixing. */
+    draftIntegration?: never;
+} | {
+    /** Identifies the source-code integration type. */
+    integrationType: SourceCodeIntegrationType;
+    /** Prevents draft and persisted integration inputs from mixing. */
+    integrationId?: never;
+    /** Supplies an integration that has not been persisted. */
+    draftIntegration: IntegrationInfo;
+};
+/** Returns repositories discovered from a source-code integration. */
+export interface DiscoverSourceRepositoriesResponse {
+    /** Lists repositories available for selection. */
+    repositories: SourceRepository[];
+}
+/** Represents a normalized GitHub repository selection. */
+export interface NormalizedGitHubRepositorySelection {
+    /** Stores the accepted legacy selection when canonical metadata is absent. */
+    legacyRepository?: string;
+    /** Lists validated canonical repository metadata. */
+    repositories: GitHubRepositoryConfiguration[];
+    /** Stores the validated default owner/repository name. */
+    defaultRepository: string;
+}
+/** Represents a normalized Bitbucket repository selection. */
+export interface NormalizedBitbucketRepositorySelection {
+    /** Lists validated canonical repository metadata. */
+    repositories: BitbucketRepositoryConfiguration[];
+    /** Stores the validated default workspace/repository name. */
+    defaultRepository: string;
+}
+/** Normalizes selected GitHub repositories for persistence and connector use. */
+export declare function normalizeGitHubRepositorySelection(configuration: GitHubRepositorySelectionConfiguration): NormalizedGitHubRepositorySelection;
+/** Normalizes selected Bitbucket repositories for persistence and connector use. */
+export declare function normalizeBitbucketRepositorySelection(configuration: BitbucketRepositorySelectionConfiguration): NormalizedBitbucketRepositorySelection;
+export {};

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

@@ -4,6 +4,11 @@
 export interface WebAiSearchRequest {
     /** The search query. */
     query: string;
+    /**
+     * When provided, restricts the web search to these domains (subdomains are included).
+     * Cited URLs in the response are guaranteed to belong to one of the listed domains.
+     */
+    allowedDomains?: Array<string>;
 }
 /**
  * Represents a cited URL in the search response.

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;