@squidcloud/client 1.0.500 → 1.0.502

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

@@ -1144,11 +1144,11 @@ export interface UpsertContextStatusSuccess extends BaseUpsertContextStatus {
 }
 /**
  * Names an upsert failure; `DUPLICATE_CONTENT` identifies existing content when contextId is omitted.
- * `EMBEDDING_FAILED`, `EXTRACTION_TIMED_OUT`, `PROVIDER_ACCESS_DENIED`, and `SOURCE_UNREACHABLE` may
- * succeed on retry. Document faults carry `retryable: false` because the same bytes fail again.
+ * `CONTENT_IN_FLIGHT`, `EMBEDDING_FAILED`, `EXTRACTION_TIMED_OUT`, `PROVIDER_ACCESS_DENIED`, and
+ * `SOURCE_UNREACHABLE` may succeed on retry. Document faults carry `retryable: false` because the same bytes fail again.
  * @category AI
  */
-export type UpsertContextErrorCode = 'CONTENT_TOO_LARGE' | 'DUPLICATE_CONTENT' | 'EMBEDDING_FAILED' | 'ENCRYPTED_DOCUMENT' | 'EXTRACTION_TIMED_OUT' | 'IMAGE_OVER_PROVIDER_LIMIT' | 'NO_EMBEDDABLE_CONTENT' | 'PROVIDER_ACCESS_DENIED' | 'SOURCE_OVER_PROVIDER_LIMIT' | 'SOURCE_UNREACHABLE' | 'UNREADABLE_DOCUMENT' | 'UNREADABLE_WORKBOOK' | 'UNSUPPORTED_FILE_TYPE';
+export type UpsertContextErrorCode = 'CONTENT_IN_FLIGHT' | 'CONTENT_TOO_LARGE' | 'DUPLICATE_CONTENT' | 'EMBEDDING_FAILED' | 'ENCRYPTED_DOCUMENT' | 'EXTRACTION_TIMED_OUT' | 'IMAGE_OVER_PROVIDER_LIMIT' | 'NO_EMBEDDABLE_CONTENT' | 'PROVIDER_ACCESS_DENIED' | 'SOURCE_OVER_PROVIDER_LIMIT' | 'SOURCE_UNREACHABLE' | 'UNREADABLE_DOCUMENT' | 'UNREADABLE_WORKBOOK' | 'UNSUPPORTED_FILE_TYPE';
 /**
  * The existing context a `DUPLICATE_CONTENT` rejection points at — where the byte-identical original
  * already lives.

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

@@ -399,6 +399,12 @@ export interface AiKnowledgeBaseChatOptions {
      * Composes with every `searchMode` and with `contextMetadataFilter`. Requires `graphRag.enabled`.
      */
     graphFilter?: AiKnowledgeBaseGraphFilter;
+    /**
+     * Returns superseded versions of a document (older drafts a source marked as replaced by a newer version)
+     * too, instead of only the final version. For questions pinned to a point in time ("the original model",
+     * "as of 2019"). Access control still applies.
+     */
+    includeSupersededVersions?: boolean;
 }
 /**
  * Graph scope for a knowledge-base search: restricts results to the documents under one concept.
@@ -760,6 +766,12 @@ export interface AiKnowledgeBaseSearchOptions {
      * Composes with every `searchMode` and with `contextMetadataFilter`. Requires `graphRag.enabled`.
      */
     graphFilter?: AiKnowledgeBaseGraphFilter;
+    /**
+     * Returns superseded versions of a document (older drafts a source marked as replaced by a newer version)
+     * too, instead of only the final version. For questions pinned to a point in time ("the original model",
+     * "as of 2019"). Access control still applies.
+     */
+    includeSupersededVersions?: boolean;
 }
 /**
  * A single chunk of data returned from an AI search operation.
@@ -877,6 +889,8 @@ export interface GrepKnowledgeBaseOptions {
      * and is clamped to {@link GREP_KNOWLEDGE_BASE_MAX_MATCHES}.
      */
     maxMatches?: number;
+    /** Scans the text of superseded versions too; by default only the final version of a document is scanned. */
+    includeSupersededVersions?: boolean;
 }
 /**
  * Request structure for a literal scan over a knowledge base's raw extracted text.

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

@@ -10,3 +10,48 @@ export declare const CONNECTOR_IDS: readonly ["bitbucket", "confluence", "connec
  * @category Platform
  */
 export type ConnectorId = (typeof CONNECTOR_IDS)[number];
+/** Where one file/folder sits in a connector's own tracking, independent of the KB ledger. */
+export type ConnectorPathStatusClassification = 'indexed' | 'staged' | 'failed' | 'skipped' | 'folder_tracked';
+/** The durable ingestion status of one file in the knowledge base ledger, as {@link ConnectorPathStatusEntry.kbStatus}. */
+export interface ConnectorKbFileStatus {
+    /** The file's current durable status in the knowledge base ledger. */
+    status: 'no_record' | 'in_progress' | 'completed' | 'failed';
+    /** Present only when `status` is `'failed'`. */
+    errorMessage?: string;
+    /** Present only when `status` is `'failed'`, when known. */
+    errorCode?: string;
+    /** When this status was last recorded; absent when `status` is `'no_record'`. */
+    updatedAt?: Date;
+}
+/** One file or folder a connector knows about at or under a searched path. */
+export interface ConnectorPathStatusEntry {
+    /** The connector-specific id of the document. */
+    documentId: string;
+    /** The document's name. */
+    name: string;
+    /** Whether this document is a file or a folder. */
+    type: 'file' | 'folder';
+    /** Folder path, when this document was indexed through a folder. With `name`, forms the KB ledger's lookup path. */
+    folderPath?: string;
+    /** Where this document sits in the connector's own tracking. */
+    classification: ConnectorPathStatusClassification;
+    /** Message describing the most recent failure, when `classification` is `'failed'` or `'skipped'`. */
+    errorMessage?: string;
+    /** Last successful ingestion, when the document has one. */
+    lastIndexedDate?: Date;
+    /** The knowledge-base context ID this document maps to, when it has one. */
+    contextId?: string;
+    /** The KB ledger's own status for this file, when the connector resolved one. */
+    kbStatus?: ConnectorKbFileStatus;
+}
+/** A connector's own record of files/folders matching a searched path, from `Squid.getConnectorPathStatus`. */
+export interface ConnectorPathStatusResult {
+    /** False when the integration's type doesn't expose path-status search (most types). */
+    supported: boolean;
+    /** The knowledge base this integration indexes into, when resolvable. */
+    knowledgeBaseId?: string;
+    /** The matching files/folders, absent when `supported` is false. */
+    entries?: Array<ConnectorPathStatusEntry>;
+    /** True when more matches exist than `entries` returns. */
+    truncated?: boolean;
+}

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

@@ -122,6 +122,65 @@ export interface SetAiKnowledgeBaseContextScopesResponse {
     /** How many chunks of the context had their scopes rewritten. */
     updatedChunkCount: number;
 }
+/**
+ * Where a context stands in its version family, as computed by the source that owns the family rules.
+ * @category AI
+ */
+export interface AiKnowledgeBaseContextVersionState {
+    /** Stable id of the family, namespaced by the source (integration + site/drive). */
+    familyId: string;
+    /** Sortable rank key within the family: larger is more final. */
+    versionKey: string;
+    /** Revision of the rule set that produced this state. */
+    rulesRevision: string;
+    /** Whether a newer version of the same document makes this one superseded. */
+    superseded: boolean;
+    /** The context that supersedes this one; present when `superseded`. */
+    winnerContextId?: string;
+    /** Why the winner ranks above this context (`final-marker`, `higher-version`, ...). */
+    reason?: string;
+}
+/** Most contexts one {@link SetAiKnowledgeBaseContextVersionStatesRequest} may carry. */
+export declare const MAX_AI_KNOWLEDGE_BASE_VERSION_STATE_BATCH = 250;
+/**
+ * One context and its new version state.
+ * @category AI
+ */
+export interface AiKnowledgeBaseContextVersionStateItem {
+    /** The id of the AiKnowledgeBaseContext whose version state is replaced */
+    contextId: string;
+    /** The new version state; absent clears it, which makes the context a regular, never-superseded one. */
+    versionState?: AiKnowledgeBaseContextVersionState;
+}
+/**
+ * Request structure for replacing the version state of a batch of AiKnowledgeBaseContexts.
+ * @category AI
+ */
+export interface SetAiKnowledgeBaseContextVersionStatesRequest {
+    /** The id of the AiKnowledgeBase */
+    knowledgeBaseId: string;
+    /** At most {@link MAX_AI_KNOWLEDGE_BASE_VERSION_STATE_BATCH} items, each context at most once. */
+    items: Array<AiKnowledgeBaseContextVersionStateItem>;
+}
+/**
+ * The outcome for one context of a {@link SetAiKnowledgeBaseContextVersionStatesRequest}.
+ * @category AI
+ */
+export interface AiKnowledgeBaseContextVersionStateResult {
+    contextId: string;
+    /** False when no record exists for the context (not ingested yet, or deleted); nothing was written then. */
+    applied: boolean;
+    /** Whether the context's content is now hidden from search candidates. */
+    hidden: boolean;
+}
+/**
+ * Response structure for replacing the version state of a batch of AiKnowledgeBaseContexts.
+ * @category AI
+ */
+export interface SetAiKnowledgeBaseContextVersionStatesResponse {
+    /** One result per request item, in request order. */
+    results: Array<AiKnowledgeBaseContextVersionStateResult>;
+}
 /**
  * Request structure for getting an AiKnowledgeBaseContext
  * @category AI
@@ -396,6 +455,106 @@ export interface AiKnowledgeBaseGetGraphWriteLockStateResponse {
     /** Writers queued for an exclusive hold. */
     exclusiveWaiters: number;
 }
+/** Turns content dedup (ENG-2930) on or off for new ingests of one knowledge base. */
+export interface AiKnowledgeBaseSetContentDedupRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+    /** Whether new ingests share stored content; false keeps reads of already shared content working. */
+    enabled: boolean;
+}
+/** Runs the duplicates migration (ENG-2930) over one knowledge base. */
+export interface AiKnowledgeBaseMigrateContentDuplicatesRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+    /** `dryRun` counts only; `apply` converts copies and hides their storage; `purge` deletes what was hidden. */
+    mode: 'dryRun' | 'apply' | 'purge';
+    /** Upper bound on the groups this run changes; omitted = all. */
+    maxGroups?: number;
+}
+/** What one duplicates-migration run found and did. */
+export interface AiKnowledgeBaseMigrateContentDuplicatesResponse {
+    /** Groups of identical contexts not yet stored once. */
+    groups: number;
+    /** Redundant copies across those groups. */
+    copies: number;
+    /** Groups this run changed. */
+    processedGroups: number;
+    /** Chunks this run hid. */
+    chunksHidden: number;
+    /** Hidden chunks this run deleted. */
+    chunksDeleted: number;
+}
+/** Drops the chunk search indexes superseded by `vector_idx_v4` and `bm25_idx_v2` (ENG-2917). */
+export interface AiKnowledgeBaseDropSupersededSearchIndexesRequest {
+    /** One `kb_chunks_<dim>` collection; omitted = every chunk collection. */
+    embeddingDimensions?: number;
+    /** Reports what would be dropped, and why or why not, without dropping anything. */
+    dryRun: boolean;
+    /** Required to drop: every pod of the deployment runs with version suppression on (one pod cannot check). */
+    allPodsSuppressionEnabled?: boolean;
+}
+/** Per chunk collection, the superseded search indexes found and dropped. */
+export interface AiKnowledgeBaseDropSupersededSearchIndexesResponse {
+    collections: Array<{
+        /** The chunk collection. */
+        collection: string;
+        /** The superseded indexes present that may go. */
+        droppable: Array<string>;
+        /** The indexes dropped; empty on a dry run. */
+        dropped: Array<string>;
+        /** Why they may or may not go. */
+        reason: string;
+    }>;
+}
+/** Test only: makes index-state probes of one chunk collection treat the named search indexes as not READY. */
+export interface AiKnowledgeBaseHoldChunkSearchIndexesRequest {
+    /** The `kb_chunks_<dim>` collection. */
+    embeddingDimensions: number;
+    /** The indexes to hold; an empty list releases the collection. */
+    indexNames: Array<string>;
+}
+/** The collection's read targets, probed right after the hold changed. */
+export interface AiKnowledgeBaseHoldChunkSearchIndexesResponse {
+    vectorIndexName: string;
+    bm25IndexName: string;
+    /** Whether reads apply the `hidden` predicate. */
+    hiddenFilterReady: boolean;
+}
+/** Test only: parks the next same-content re-ingest of a context between its read and its reservation. */
+export interface AiKnowledgeBaseParkSameKeyReingestRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+    /** `arm` parks the next re-ingest of `contextId`, `release` lets it go, `status` only reports. */
+    action: 'arm' | 'release' | 'status';
+    /** The re-ingested context; required to arm. */
+    contextId?: AiContextId;
+}
+/** Whether a re-ingest is parked now. */
+export interface AiKnowledgeBaseParkSameKeyReingestResponse {
+    parked: boolean;
+}
+/** Checks the content model (ENG-2930) of one knowledge base. */
+export interface AiKnowledgeBaseCheckContentDedupRequest {
+    /** The ID of the App */
+    appId: AppId;
+    /** The ID of the AIKnowledgeBase */
+    knowledgeBaseId: AiKnowledgeBaseId;
+}
+/** The invariant-check outcome of one knowledge base's content model. */
+export interface AiKnowledgeBaseCheckContentDedupResponse {
+    /** Live contents. */
+    contents: number;
+    /** Placements of live contents. */
+    placements: number;
+    /** Every broken invariant found; empty when the model is consistent. */
+    violations: Array<string>;
+}
 /**
  * Request structure for the internal test-only route that sets a knowledge base's graph schema version.
  * A migration test needs a KB on the older schema, which the creation path never produces.

package/dist/internal-common/src/utils/connector-path-status.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The registry of connectors that support path-status search, plus the shared dispatch logic that
+ * calls the right one by integration type. `ExecuteFunctionLike` duck-types the subset of
+ * `@squidcloud/client`'s `Squid` this needs; see `SquidServiceLike` in `./squid-service.utils` for
+ * the same pattern.
+ */
+import { IntegrationId } from '../public-types/communication.public-types';
+import { ConnectorPathStatusResult } from '../public-types/connector.public-types';
+import { IntegrationType } from '../public-types/integration.public-types';
+/** How to call one connector's `get<X>PathStatus` executable: its name and its calling convention. */
+export interface PathStatusExecutable {
+    functionName: string;
+    buildArgs: (integrationId: IntegrationId, path: string) => Array<unknown>;
+}
+/** Absent for a type ⇒ that connector doesn't track file/folder hierarchy beyond the KB ledger. */
+export declare const PATH_STATUS_EXECUTABLE_BY_TYPE: Partial<Record<IntegrationType, PathStatusExecutable>>;
+/** The subset of `Squid` (`@squidcloud/client`) this dispatch needs. */
+export interface ExecuteFunctionLike {
+    executeFunction<T>(functionName: string, ...args: Array<unknown>): Promise<T>;
+}
+/**
+ * Searches a connector's own record of files/folders at a path, for connectors registered in
+ * {@link PATH_STATUS_EXECUTABLE_BY_TYPE}. Returns `{ supported: false }` when `integrationType` isn't
+ * registered — most integration types don't support this, and that's not an error. The caller (e.g.
+ * `IntegrationClient.getPathStatus`) already has the integration, so this doesn't re-fetch it.
+ */
+export declare function getConnectorPathStatus(executor: ExecuteFunctionLike, integrationType: IntegrationType, integrationId: IntegrationId, path: string): Promise<ConnectorPathStatusResult>;

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

@@ -11,6 +11,7 @@ export declare class AdminClient {
     private readonly region;
     private readonly appId;
     private readonly consoleRegion;
+    private readonly backendFunctionManager;
     private readonly integrationClient;
     private readonly connectorClient;
     private readonly secretClient;

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

@@ -1,4 +1,4 @@
-import { DiscoverSourceRepositoriesResponse, IntegrationId, IntegrationInfo, IntegrationType } from './public-types';
+import { ConnectorPathStatusResult, DiscoverSourceRepositoriesResponse, IntegrationId, IntegrationInfo, IntegrationType, JobId } from './public-types';
 /**
  * IntegrationClient manages integrations within an application,
  * providing methods for listing, retrieving, updating, and deleting integrations.
@@ -6,6 +6,7 @@ import { DiscoverSourceRepositoriesResponse, IntegrationId, IntegrationInfo, Int
  */
 export declare class IntegrationClient {
     private readonly rpcManager;
+    private readonly backendFunctionManager;
     private readonly iacBaseUrl;
     /**
      * Lists all enabled integrations for the current application.
@@ -23,6 +24,18 @@ export declare class IntegrationClient {
      * @returns A promise that resolves with the integration info, or `undefined` if not found.
      */
     get<ConfigurationType = Record<string, any>>(integrationId: IntegrationId): Promise<IntegrationInfo<ConfigurationType> | undefined>;
+    /**
+     * Searches a connector's own record of files/folders at a path — for connectors (SharePoint, and
+     * any future file/folder-hierarchy connector) that track more than the AI knowledge base ledger
+     * does. Returns `{ supported: false }` when the integration's type doesn't support this. The
+     * connector's own executable requires an API key, so this call fails unless the `Squid` instance
+     * is authenticated with one.
+     *
+     * @param integrationId - The ID of the integration to search.
+     * @param path - The path, folder, or filename to search for.
+     * @returns A promise that resolves to the connector's path-status result.
+     */
+    getPathStatus(integrationId: IntegrationId, path: string): Promise<ConnectorPathStatusResult>;
     /**
      * Enables a disabled integration. The integration becomes available again for runtime access and sync jobs.
      *
@@ -123,6 +136,32 @@ export declare class IntegrationClient {
      * @returns A promise that resolves with the discovered schema and collection readiness information.
      */
     discoverDataConnectionSchema<SchemaType = Record<string, any>>(integrationId: IntegrationId): Promise<DiscoverDataConnectionSchemaResponse<SchemaType>>;
+    /**
+     * Starts inferring relationships from the data of a database integration, in the background, over its
+     * stored schema. It finds relationships no foreign key declares, discriminator columns, and columns that
+     * depend on each other, and writes the findings at the minimum confidence or above into the stored schema.
+     * Fails while another run of the integration is active.
+     *
+     * @param integrationId - The ID of the database integration.
+     * @param options - (Optional) What to look for and how much to spend on it.
+     * @returns A promise that resolves with the run's job ID, for `squid.jobs().awaitJob(jobId)`.
+     */
+    startRelationshipInference(integrationId: IntegrationId, options?: RelationshipInferenceOptions): Promise<JobId>;
+    /**
+     * Returns the latest relationship-inference run of a database integration, with its progress and findings.
+     *
+     * @param integrationId - The ID of the database integration.
+     * @returns A promise that resolves with the run, or `undefined` when the integration never had one.
+     */
+    getRelationshipInference<ItemType = Record<string, any>>(integrationId: IntegrationId): Promise<RelationshipInferenceRun<ItemType> | undefined>;
+    /**
+     * Stops the active relationship-inference run of a database integration. The run still writes what it
+     * found so far, and ends as 'cancelled'.
+     *
+     * @param integrationId - The ID of the database integration.
+     * @returns A promise that resolves when the run is asked to stop.
+     */
+    cancelRelationshipInference(integrationId: IntegrationId): Promise<void>;
     /**
      * Tests a data connection (database) to verify it is working.
      * Attempts to connect to the database and perform a basic operation to validate connectivity.
@@ -279,6 +318,104 @@ export interface DiscoverDataConnectionSchemaResponse<SchemaType = Record<string
      * Information about collection readiness for CRUD operations and replication.
      */
     collectionReadiness: Record<string, CollectionReadiness>;
+    /**
+     * What discovery could not read, such as the declared foreign keys, and kept as it was.
+     */
+    warnings?: string[];
+}
+/**
+ * Options for a relationship-inference run.
+ * @category Platform
+ */
+export interface RelationshipInferenceOptions {
+    /** What to look for. Defaults to all three. */
+    kinds?: Array<'relationships' | 'dependencies' | 'discriminators'>;
+    /** Collections to examine, on both sides. Defaults to every collection in the schema. */
+    collections?: string[];
+    /** Instructions about the data, for the AI; given, they turn `useAi` on. */
+    instructions?: string;
+    /** Lets the AI propose relationships that names miss, settle close calls, and describe the associations it adds. Off by default. */
+    useAi?: boolean;
+    /** The lowest confidence written to the schema. Defaults to 'medium'. */
+    minConfidence?: 'high' | 'medium' | 'low';
+    /** Rows sampled per collection; every finding is judged on them. Defaults to 1,000. */
+    sampleSize?: number;
+    /** Also checks every finding on all rows, at one more query each. Off by default. */
+    verifyOnAllRows?: boolean;
+    /** When the run stops and keeps what it has: 60 minutes by default, or 240 with `verifyOnAllRows`; at most 1,440. */
+    maxDurationMinutes?: number;
+    /** Queries in flight at once. Defaults to 2; at most 8 and the integration's pool size. */
+    concurrency?: number;
+}
+/**
+ * A relationship-inference run of a database integration.
+ * @category Platform
+ */
+export interface RelationshipInferenceRun<ItemType = Record<string, any>> {
+    /** The ID of the database integration. */
+    integrationId: IntegrationId;
+    /** Whether the run is still going, and how it ended. */
+    status: 'running' | 'completed' | 'cancelled' | 'failed';
+    /** What the run does now, or 'done'. */
+    phase: 'profiling' | 'matching' | 'in-table' | 'verifying' | 'describing' | 'applying' | 'done';
+    /** The options the run was started with. */
+    options: RelationshipInferenceOptions;
+    /** How far the run got. */
+    progress: RelationshipInferenceProgress;
+    /** When the run started, in milliseconds since the epoch. */
+    startedAt: number;
+    /** When the run ended, in milliseconds since the epoch. */
+    endedAt?: number;
+    /** True when the time budget or a cancel ended the run before it judged every candidate. */
+    partial: boolean;
+    /** Why the run failed. */
+    error?: string;
+    /** Everything the run found, whether or not it went into the schema. Empty until the run ends. */
+    findings: Array<RelationshipInferenceFinding<ItemType>>;
+    /** Signatures of earlier inferred items this complete run did not find again, which it removed from the stored schema. */
+    removed?: Array<string>;
+}
+/**
+ * How far a relationship-inference run got.
+ * @category Platform
+ */
+export interface RelationshipInferenceProgress {
+    /** Collections to sample. */
+    collections: number;
+    /** Collections sampled so far. */
+    collectionsProfiled: number;
+    /** Key columns to check referencing columns against. */
+    keys: number;
+    /** Key columns checked so far. */
+    keysProbed: number;
+    /** Findings to check on all rows, with `verifyOnAllRows`. */
+    findingsToVerify: number;
+    /** Findings checked on all rows so far. */
+    findingsVerified: number;
+    /** Queries sent to the database so far. */
+    queries: number;
+}
+/**
+ * One thing a relationship-inference run found.
+ * @category Platform
+ */
+export interface RelationshipInferenceFinding<ItemType = Record<string, any>> {
+    /** Identifies the finding; without its kind prefix, it is the item's key in the schema. */
+    signature: string;
+    /** Which of `association`, `discriminator` and `dependency` holds the finding. */
+    kind: 'association' | 'discriminator' | 'dependency';
+    /** Whether the finding passed every check at the minimum confidence or above. */
+    eligible?: boolean;
+    /** Whether the finding went into the stored schema. */
+    applied: boolean;
+    /** Why the finding did not go into the stored schema. */
+    notAppliedReason?: string;
+    /** A relationship between two collections, as the schema's `associations` hold it. */
+    association?: ItemType;
+    /** A column whose value decides what the rest of its row means, as the schema's `discriminators` hold it. */
+    discriminator?: ItemType;
+    /** Two columns of a row that fix each other, as the schema's `columnDependencies` hold it. */
+    dependency?: ItemType;
 }
 /**
  * Response from testing a data connection.

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

@@ -2,4 +2,4 @@
  * The current version of the SquidCloud client package.
  * @category Platform
  */
-export declare const SQUIDCLOUD_CLIENT_PACKAGE_VERSION = "1.0.500";
+export declare const SQUIDCLOUD_CLIENT_PACKAGE_VERSION = "1.0.502";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.500",
+  "version": "1.0.502",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",