@hydradb/sdk 2.1.4 → 2.1.6

package/README.md

@@ -235,8 +235,8 @@ metadata, checking processing status, reading graph relations, and deleting.
 
 `POST /context/ingest` (multipart) → `HandlerEnvelopeIngestionV2SourceUploadResponse`
 
-Ingest knowledge documents or memories. `documents` is a file upload; the other structured
-fields are JSON strings.
+Ingest knowledge documents or memories. `documents` is a list of file uploads (one request may
+carry several); the other structured fields are JSON strings.
 
 ```typescript
 import { createReadStream } from "fs";
@@ -244,11 +244,14 @@ import { createReadStream } from "fs";
 // Ingest a document file
 const res = await client.context.ingest({
   database: "acme-corp",                 // required
-  documents: createReadStream("handbook.pdf"),
+  documents: [createReadStream("handbook.pdf")],  // one entry per file
   collection: "hr",
   type: "knowledge",
-  // documentMetadata is a JSON *array* — one object per uploaded file.
-  documentMetadata: JSON.stringify([{ title: "Employee Handbook", author: "HR" }]),
+  // documentMetadata is a JSON *array* — one object per uploaded file. Your own
+  // per-document fields go under `additional_metadata`; the item's other top-level keys
+  // are the API's (metadata, evidence_kind, evidence_subject, id, relations, ...) —
+  // an unknown top-level key such as `title` is rejected with 400.
+  documentMetadata: JSON.stringify([{ additional_metadata: { title: "Employee Handbook", author: "HR" } }]),
   upsert: "true",                        // form field is a string
 });
 
@@ -265,9 +268,9 @@ await client.context.ingest({
 | Field              | Type                     | Notes |
 | ------------------ | ------------------------ | ----- |
 | `database`         | `string` (required)      | Database (tenant scope). Alias: `tenantId`. |
-| `documents`        | `Uploadable`             | File upload (stream, `Blob`, `Buffer`, etc.). |
+| `documents`        | `Uploadable[]`           | File uploads (stream, `Blob`, `Buffer`, etc.), one entry per file. |
 | `memories`         | `string`                 | JSON **array** string; each item needs `text` (or `user_assistant_pairs`). |
-| `documentMetadata` | `string`                 | JSON **array** string of per‑document metadata — one object per uploaded file (count must match). |
+| `documentMetadata` | `string`                 | JSON **array** string — one object per uploaded file (count must match). Put your own fields under `additional_metadata`; the API's item keys (`metadata`, `evidence_kind`, `evidence_subject`, `id`, `relations`, ...) may sit alongside it. Unknown top-level keys return 400. |
 | `appKnowledge`     | `string`                 | App‑knowledge items as a JSON **array** string (not raw text). |
 | `graphPayload`     | `string`                 | Pre‑computed graph payload. |
 | `collection`       | `string`                 | Collection (sub‑tenant scope). Alias: `subTenantId`. |

package/dist/Client.d.ts

@@ -51,7 +51,7 @@ export declare class HydraDBClient {
     listProviders(request?: HydraDB.ListProvidersRequest, requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerProviderListResponse>;
     private __listProviders;
     /**
-     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids.
+     * Unified query endpoint that dispatches across type and query_by (hybrid/text). Optionally filter by one or more exact document titles with `titles`; these are resolved to source IDs before normal retrieval. Filter with `attributes` (an operator language, pushed into the vector search); `metadata_filters` is deprecated in favour of it and still works. `type` is knowledge (the default), memory, or all (both, merged). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids. The response body always carries `llm_prompt`: the whole result rendered as a single Markdown string (results, related facts, temporal facts, profiles and sources, with citable ids inline), ready to inject verbatim into an LLM context.
      *
      * @param {HydraDB.SearchQueryRequest} request
      * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/Client.js

@@ -180,7 +180,7 @@ class HydraDBClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/connectors/providers");
     }
     /**
-     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids.
+     * Unified query endpoint that dispatches across type and query_by (hybrid/text). Optionally filter by one or more exact document titles with `titles`; these are resolved to source IDs before normal retrieval. Filter with `attributes` (an operator language, pushed into the vector search); `metadata_filters` is deprecated in favour of it and still works. `type` is knowledge (the default), memory, or all (both, merged). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids. The response body always carries `llm_prompt`: the whole result rendered as a single Markdown string (results, related facts, temporal facts, profiles and sources, with citable ids inline), ready to inject verbatim into an LLM context.
      *
      * @param {HydraDB.SearchQueryRequest} request
      * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/api/client/requests/SearchQueryRequest.d.ts

@@ -20,6 +20,29 @@ export interface SearchQueryRequest {
     additionalContext?: string;
     /** Weighting balance between dense and sparse retrieval in hybrid mode. `"auto"` lets HydraDB choose; a number from 0 (full BM25) to 1 (full dense) sets it explicitly. */
     alpha?: unknown;
+    /**
+     * Attributes is the go-forward metadata filter: a MongoDB-like operator query
+     * ($eq/$ne/$gt/$gte/$lt/$lte/$in/$nin/$and/$or/$not/$exists) over the
+     * database attributes, translated to a safe Milvus scalar pre-filter by
+     * BuildAttributesFilterExpr (PRO-1618). It composes (AND) with the
+     * deprecated metadata_filters while both exist. Field names are allowlisted
+     * and values escaped, so it is injection-safe.
+     *
+     * It is applied everywhere metadata_filters is, and nowhere else: the
+     * chunks a query returns, the additional context and forceful-relation
+     * chunks (the fail-closed post-filter net in the service), and the graph
+     * paths, which the graph lane prunes by resolving every source a path
+     * cites and dropping the paths that touch one failing the predicate
+     * (disallowedGraphSources). Product decision 2026-09-04: `attributes`
+     * behaves like `metadata_filters` on every part of the response.
+     */
+    attributes?: Record<string, unknown>;
+    /**
+     * CodeSearch forces the repository code-search branch on (true) or off
+     * (false) for this query, overriding the classifier. Nil = let the
+     * classifier decide. Only meaningful where the branch is enabled.
+     */
+    codeSearch?: boolean;
     /** Collection scope. Defaults to the default collection when omitted. Formerly `sub_tenant_id`; the `sub_tenant_id` alias is still accepted (deprecated). */
     collection?: string;
     /** Preferred /query scope selector. Send either a list of collection IDs for equal normalized weighting, or an object mapping collection ID to a positive relative ranking weight with at most one decimal place. Do not send together with the deprecated sub_tenant_ids or sub_tenant_id. */
@@ -31,6 +54,8 @@ export interface SearchQueryRequest {
      * handler reads it; Database/Collection are carried only for docs/OpenAPI.
      */
     database?: string;
+    /** Whether to follow the relations the author declared at ingest (forceful_relations) and return the related contexts. Defaults to true when omitted. */
+    followForcefulRelations?: boolean;
     /** Whether to include graph context in the response. Defaults to true for /query when omitted. */
     graphContext?: boolean;
     /**
@@ -70,15 +95,28 @@ export interface SearchQueryRequest {
     /** Number of adjacent chunks to pull alongside each matched chunk for additional context. */
     numRelatedChunks?: number;
     operator?: HydraDB.SearchOperator;
+    /**
+     * ProfileEntityType/ProfileNamespace refine the subject's graph identity;
+     * defaults ("PERSON"/"users") cover the common case of a person subject.
+     */
+    profileEntityType?: string;
+    profileNamespace?: string;
+    /**
+     * ProfileSubject names the entity whose compiled profile should ride the
+     * response as profile_context/profile_filter (PRO-1797). Payload-only:
+     * chunk ranking is never altered. Omitted = no profile block. Dark until
+     * the repo-level ENTITY_PROFILE_CONTEXT_ENABLED flag is on.
+     */
+    profileSubject?: string;
     /** Natural-language search query. */
     query?: string;
-    /** Whether to include app-aware knowledge retrieval. Applies to knowledge hybrid queries. */
+    /** Whether to include app-aware knowledge retrieval. Applies to knowledge hybrid queries. Defaults to true when omitted; pass false to search files only. */
     queryApps?: boolean;
     /** Retrieval method to use for the query. */
     queryBy?: HydraDB.SearchQueryBy;
-    /** Whether to force relation expansion for graph-aware query retrieval. Defaults to true when omitted. */
+    /** Deprecated alias for follow_forceful_relations. Ignored when follow_forceful_relations is sent. */
     queryForcefulRelations?: boolean;
-    /** Recency boost applied to ranking. 0 disables it; higher values favour more recent sources. */
+    /** Recency boost applied to ranking (0.0-1.0). Omit it to get the always-on default baseline of 0.40 (a bounded <=40% swing on normalized relevance — it reorders within a relevance gap of up to 0.40 but never buries a more strongly relevant result); send 0 to disable recency entirely; higher values favour more recent sources more strongly. */
     recencyBias?: number;
     /** Deprecated for /query (since 2.0.1). Use collection for a single scope or collections for multiple. Backwards-compatible and will be removed in a future version. Do not send together with a multi-scope selector. */
     subTenantId?: string;
@@ -106,6 +144,8 @@ export interface SearchQueryRequest {
     temporalReasoning?: boolean;
     /** deprecated: use database */
     tenantId?: string;
-    /** Corpus to query: knowledge, memory, or all. */
+    /** Optional exact document-title filter. Values are matched case-insensitively and ORed, resolved to source IDs, then the normal query pipeline runs within that source scope. When ids is also supplied, the two filters are intersected. */
+    titles?: string[];
+    /** Deprecated: kept for split databases. Corpus to query: knowledge (the default), memory, or all (both, merged). */
     type?: HydraDB.SearchSourceType;
 }

package/dist/api/resources/connectors/client/Client.d.ts

@@ -174,6 +174,7 @@ export declare class ConnectorsClient {
      * @throws {@link HydraDB.NotFoundError}
      * @throws {@link HydraDB.InternalServerError}
      * @throws {@link HydraDB.BadGatewayError}
+     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
      *     await client.connectors.discover({
@@ -182,6 +183,23 @@ export declare class ConnectorsClient {
      */
     discover(request: HydraDB.DiscoverConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerDiscoverResponseBody>;
     private __discover;
+    /**
+     * Stop scheduling syncs and backfills for a connector until it is resumed. A sync already running is allowed to finish. Cursors are preserved, so resuming continues from where each resource left off.
+     *
+     * @param {HydraDB.PauseConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.ConflictError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.pause({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    pause(request: HydraDB.PauseConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorPauseResponse>;
+    private __pause;
     /**
      * List the configured resources for a connector.
      *
@@ -256,7 +274,24 @@ export declare class ConnectorsClient {
     updateResourceAcl(request: HydraDB.UpdateResourceAclConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
     private __updateResourceAcl;
     /**
-     * Report whether a connector is working, in one call: a rollup status (healthy, degraded, failed, checking) plus per-resource detail. `degraded` means the connector is syncing but at least one configured resource is failing — the state that is otherwise invisible, because a connector whose resources partly fail still reports an idle sync status and no error.
+     * Return a paused connector to the schedule and make it due immediately. Each resource continues from its committed cursor, so data created during the pause is collected on the next cycle rather than skipped.
+     *
+     * @param {HydraDB.ResumeConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.ConflictError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.resume({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    resume(request: HydraDB.ResumeConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorPauseResponse>;
+    private __resume;
+    /**
+     * Report whether a connector is working, in one call: a rollup status (healthy, degraded, failed, checking) plus per-resource detail. `degraded` means the connector is scheduled but not fully working: at least one configured resource is failing, or the latest sync cycle failed after the resources reported (in which case `error` carries the failure and `retryable` says whether waiting can fix it). `failed` means only the user can fix it: a rejected credential, a blocked connector, or a terminal cycle failure.
      *
      * @param {HydraDB.StatusConnectorsRequest} request
      * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -289,4 +324,48 @@ export declare class ConnectorsClient {
      */
     sync(request: HydraDB.SyncConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorSyncResponse>;
     private __sync;
+    /**
+     * List metadata and field names for credentials already used by connectors in the current workspace.
+     *
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.connectors.listConnectorCredentials()
+     */
+    listConnectorCredentials(requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerVaultCredentialListResponse>;
+    private __listConnectorCredentials;
+    /**
+     * Update fields on the credential currently used by a connector. Owner-only human action.
+     *
+     * @param {HydraDB.HandlerVaultCredentialUpdateReq} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     *
+     * @example
+     *     await client.connectors.updateConnectorCredentials({
+     *         id: "HydraDoc1234",
+     *         credentials: {
+     *             "api_token": "xoxb-..."
+     *         }
+     *     })
+     */
+    updateConnectorCredentials(request: HydraDB.HandlerVaultCredentialUpdateReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerVaultCredentialUpdateResponse>;
+    private __updateConnectorCredentials;
+    /**
+     * Reveal one field from the credential currently used by a connector in the workspace. The response must never be cached.
+     *
+     * @param {HydraDB.HandlerVaultCredentialRevealReq} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     *
+     * @example
+     *     await client.connectors.revealAConnectorCredentialValue({
+     *         id: "HydraDoc1234",
+     *         field: "field"
+     *     })
+     */
+    revealAConnectorCredentialValue(request: HydraDB.HandlerVaultCredentialRevealReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerVaultCredentialRevealResponse>;
+    private __revealAConnectorCredentialValue;
 }

package/dist/api/resources/connectors/client/Client.js

@@ -683,6 +683,7 @@ class ConnectorsClient {
      * @throws {@link HydraDB.NotFoundError}
      * @throws {@link HydraDB.InternalServerError}
      * @throws {@link HydraDB.BadGatewayError}
+     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
      *     await client.connectors.discover({
@@ -751,6 +752,14 @@ class ConnectorsClient {
                         skipValidation: true,
                         breadcrumbsPrefix: ["response"],
                     }), _response.rawResponse);
+                case 503:
+                    throw new HydraDB.ServiceUnavailableError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -761,6 +770,71 @@ class ConnectorsClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/connectors/{id}/discover");
     }
+    /**
+     * Stop scheduling syncs and backfills for a connector until it is resumed. A sync already running is allowed to finish. Cursors are preserved, so resuming continues from where each resource left off.
+     *
+     * @param {HydraDB.PauseConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.ConflictError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.pause({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    pause(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__pause(request, requestOptions));
+    }
+    async __pause(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.HydraDBEnvironment.Default, `connectors/${core.url.encodePathParam(id)}/pause`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.HandlerConnectorPauseResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 404:
+                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new HydraDB.ConflictError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.HydraDBError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/connectors/{id}/pause");
+    }
     /**
      * List the configured resources for a connector.
      *
@@ -1055,7 +1129,72 @@ class ConnectorsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "PATCH", "/connectors/{id}/resources/{resource_id}");
     }
     /**
-     * Report whether a connector is working, in one call: a rollup status (healthy, degraded, failed, checking) plus per-resource detail. `degraded` means the connector is syncing but at least one configured resource is failing — the state that is otherwise invisible, because a connector whose resources partly fail still reports an idle sync status and no error.
+     * Return a paused connector to the schedule and make it due immediately. Each resource continues from its committed cursor, so data created during the pause is collected on the next cycle rather than skipped.
+     *
+     * @param {HydraDB.ResumeConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.ConflictError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.resume({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    resume(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__resume(request, requestOptions));
+    }
+    async __resume(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.HydraDBEnvironment.Default, `connectors/${core.url.encodePathParam(id)}/resume`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.HandlerConnectorPauseResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 404:
+                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new HydraDB.ConflictError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.HydraDBError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/connectors/{id}/resume");
+    }
+    /**
+     * Report whether a connector is working, in one call: a rollup status (healthy, degraded, failed, checking) plus per-resource detail. `degraded` means the connector is scheduled but not fully working: at least one configured resource is failing, or the latest sync cycle failed after the resources reported (in which case `error` carries the failure and `retryable` says whether waiting can fix it). `failed` means only the user can fix it: a rejected credential, a blocked connector, or a terminal cycle failure.
      *
      * @param {HydraDB.StatusConnectorsRequest} request
      * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -1190,5 +1329,187 @@ class ConnectorsClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/connectors/{id}/sync");
     }
+    /**
+     * List metadata and field names for credentials already used by connectors in the current workspace.
+     *
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.connectors.listConnectorCredentials()
+     */
+    listConnectorCredentials(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__listConnectorCredentials(requestOptions));
+    }
+    async __listConnectorCredentials(requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.HydraDBEnvironment.Default, "credential-vault"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.HandlerVaultCredentialListResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            throw new errors.HydraDBError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/credential-vault");
+    }
+    /**
+     * Update fields on the credential currently used by a connector. Owner-only human action.
+     *
+     * @param {HydraDB.HandlerVaultCredentialUpdateReq} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     *
+     * @example
+     *     await client.connectors.updateConnectorCredentials({
+     *         id: "HydraDoc1234",
+     *         credentials: {
+     *             "api_token": "xoxb-..."
+     *         }
+     *     })
+     */
+    updateConnectorCredentials(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__updateConnectorCredentials(request, requestOptions));
+    }
+    async __updateConnectorCredentials(request, requestOptions) {
+        const { id, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.HydraDBEnvironment.Default, `credential-vault/${core.url.encodePathParam(id)}`),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.HandlerVaultCredentialUpdateReq.jsonOrThrow(_body, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.HandlerVaultCredentialUpdateResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 404:
+                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.HydraDBError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "PATCH", "/credential-vault/{id}");
+    }
+    /**
+     * Reveal one field from the credential currently used by a connector in the workspace. The response must never be cached.
+     *
+     * @param {HydraDB.HandlerVaultCredentialRevealReq} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     *
+     * @example
+     *     await client.connectors.revealAConnectorCredentialValue({
+     *         id: "HydraDoc1234",
+     *         field: "field"
+     *     })
+     */
+    revealAConnectorCredentialValue(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__revealAConnectorCredentialValue(request, requestOptions));
+    }
+    async __revealAConnectorCredentialValue(request, requestOptions) {
+        const { id, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.HydraDBEnvironment.Default, `credential-vault/${core.url.encodePathParam(id)}/reveal`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.HandlerVaultCredentialRevealReq.jsonOrThrow(_body, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.HandlerVaultCredentialRevealResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 404:
+                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.HydraDBError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/credential-vault/{id}/reveal");
+    }
 }
 exports.ConnectorsClient = ConnectorsClient;

package/dist/api/resources/connectors/client/requests/HandlerConfigureReq.d.ts

@@ -25,6 +25,13 @@ export interface HandlerConfigureReq {
     id: string;
     /** Internal interval for async backfill paging. */
     backfillChunkIntervalSeconds?: number;
+    /**
+     * FullVisibilityRoles names the HubSpot roles whose members can see every
+     * record (PRO-2036). Resolved to ids against the portal at configure time
+     * and stored on the account-wide resource row. A pointer so an omitted
+     * field keeps the current setting while an explicit [] clears it.
+     */
+    fullVisibilityRoles?: string[];
     /** How far back the first sync fetches historical data. Only applies to the initial sync — subsequent syncs are incremental from the last cursor. */
     lookbackDays?: number;
     /** Resources to activate for this connector. Each item corresponds to one entry from the Discover endpoint. */

package/dist/api/resources/connectors/client/requests/HandlerVaultCredentialRevealReq.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234",
+ *         field: "field"
+ *     }
+ */
+export interface HandlerVaultCredentialRevealReq {
+    /** Connector ID */
+    id: string;
+    field: string;
+}

package/dist/api/resources/connectors/client/requests/HandlerVaultCredentialUpdateReq.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234",
+ *         credentials: {
+ *             "api_token": "xoxb-..."
+ *         }
+ *     }
+ */
+export interface HandlerVaultCredentialUpdateReq {
+    /** Connector ID */
+    id: string;
+    /** Provider-specific credentials (typically `{"api_token": "..."}` or `{"access_token": "..."}`). */
+    credentials: Record<string, unknown>;
+}