@hydradb/sdk 2.1.3 → 2.1.5

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

@@ -411,7 +411,7 @@ class ConnectorsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/connectors/{id}");
     }
     /**
-     * Update a connector's mutable settings. `sync_interval_seconds` sets the cadence at which the scheduler starts incremental syncs: the allowed range is provider-aware and returned in the response; values outside it are rejected rather than clamped; 0 resets to the provider default; changing it re-anchors the next sync so a shorter cadence takes effect immediately. `credentials` reconnects the connector in place: send the provider's full credential set (what create accepts); supplied keys replace their stored values, other stored keys survive, the bundle is re-validated against the provider's credential schema, and a pending needs-reauth flag is cleared — the connector keeps its id, resources, and sync cursors.
+     * Update a connector's mutable settings. `sync_interval_seconds` sets the cadence at which the scheduler starts incremental syncs: the allowed range is provider-aware and returned in the response; values outside it are rejected rather than clamped; 0 resets to the provider default; changing it re-anchors the next sync so a shorter cadence takes effect immediately. `credentials` reconnects the connector in place: send the provider's full credential set (what create accepts); supplied keys replace their stored values, other stored keys survive, the bundle is re-validated against the provider's credential schema, and a pending needs-reauth flag is cleared — the connector keeps its id, resources, and sync cursors. `custom_instructions` replaces the free-text steering applied when this connector's documents are ingested (an explicit empty string clears it); the change applies from the next sync cycle and does not re-process already-ingested documents. When several fields are supplied together they are validated up front and applied atomically: an invalid value rejects the whole request with nothing changed.
      *
      * @param {HydraDB.HandlerConnectorUpdateReq} request
      * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -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.
      *
@@ -974,7 +1048,153 @@ class ConnectorsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/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.
+     * Updates per-resource settings. `acl` sets the customer-declared ACL for one connector resource (PRO-1684): the rule is normalized (emails prefixed, __public__ dominates, explicit-empty becomes __private__), persisted on the resource, and applied to enforcement immediately via the resource's ACL row, every already-indexed document of the resource is governed by it on the next query, with no re-sync. For providers with provider-derived ACL capture enabled, the provider's own ACL takes precedence again at the next sync; the rule is the standing fallback. `custom_instructions` sets the resource-level ingestion-instructions override (max 4000 characters): when set it replaces the connector-level custom_instructions for documents synced from this resource, an explicit empty string clears the override back to inheriting the connector's value, and changes apply from the next sync cycle. At least one field must be supplied; omitted fields are left unchanged.
+     *
+     * @param {HydraDB.UpdateResourceAclConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.updateResourceAcl({
+     *         id: "HydraDoc1234",
+     *         resourceId: "C0123456789",
+     *         body: {
+     *             "key": "value"
+     *         }
+     *     })
+     */
+    updateResourceAcl(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__updateResourceAcl(request, requestOptions));
+    }
+    async __updateResourceAcl(request, requestOptions) {
+        const { id, resourceId, body: _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, `connectors/${core.url.encodePathParam(id)}/resources/${core.url.encodePathParam(resourceId)}`),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.connectors.updateResourceAcl.Request.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.connectors.updateResourceAcl.Response.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 400:
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
+                case 404:
+                    throw new HydraDB.NotFoundError(_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, "PATCH", "/connectors/{id}/resources/{resource_id}");
+    }
+    /**
+     * 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.
@@ -1109,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/HandlerConnectorCreateReq.d.ts

@@ -11,6 +11,12 @@ export interface HandlerConnectorCreateReq {
     collection?: string;
     /** Provider-specific credentials (typically `{"api_token": "..."}` or `{"access_token": "..."}`). */
     credentials?: Record<string, unknown>;
+    /**
+     * CustomInstructions optionally steers how this connector's synced
+     * documents are ingested and indexed. Max 4000 characters; editable later
+     * via PATCH.
+     */
+    customInstructions?: string;
     /**
      * Database/Collection are the canonical v2 names; TenantID/SubTenantID are
      * their deprecated aliases, reconciled by the TenantAliases middleware before

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

@@ -9,6 +9,12 @@ export interface HandlerConnectorUpdateReq {
     id: string;
     /** Provider-specific credentials (typically `{"api_token": "..."}` or `{"access_token": "..."}`). */
     credentials?: Record<string, unknown>;
+    /**
+     * CustomInstructions replaces the guidance applied when this connector's
+     * documents are ingested. Omitted leaves it unchanged; an explicit empty
+     * string clears it. Max 4000 characters; applies from the next sync cycle.
+     */
+    customInstructions?: string;
     /** How frequently the scheduler triggers incremental syncs, in seconds. Bounded per provider; send 0 or omit to use the provider default. Change it later with PATCH /connectors/{id}. */
     syncIntervalSeconds?: number;
 }

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

@@ -8,9 +8,21 @@
 export interface HandlerResourceCreateReq {
     /** Connector ID */
     id: string;
+    /**
+     * ACL restricts every object synced from this resource to the listed
+     * principals (see resourceMapping.ACL). Omitted means unrestricted.
+     */
+    acl?: string[];
     /** Key-value pairs merged into document metadata on every synced object from this resource. Capped at 1 KiB, measured on the compact JSON encoding of the whole map in UTF-8 bytes — keys, quotes, commas and braces count toward the budget. The cap is applied when synced objects are ingested, not to this request. */
     additionalMetadata?: Record<string, unknown>;
     collectionOverride?: string;
+    /**
+     * CustomInstructions optionally steers how documents synced from this
+     * resource are ingested and indexed. When set it replaces the
+     * connector-level custom_instructions for this resource; empty inherits
+     * the connector's value. Max 4000 characters.
+     */
+    customInstructions?: string;
     databaseOverride?: string;
     /** Human-readable name for this resource. */
     displayName?: string;

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>;
+}

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

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

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234",
+ *         resourceId: "C0123456789",
+ *         body: {
+ *             "key": "value"
+ *         }
+ *     }
+ */
+export interface UpdateResourceAclConnectorsRequest {
+    /** Connector ID */
+    id: string;
+    /** Resource ID */
+    resourceId: string;
+    body: Record<string, unknown>;
+}

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

@@ -7,8 +7,13 @@ export type { HandlerConnectorCreateReq } from "./HandlerConnectorCreateReq.js";
 export type { HandlerConnectorUpdateReq } from "./HandlerConnectorUpdateReq.js";
 export type { HandlerDiscoverPreviewReq } from "./HandlerDiscoverPreviewReq.js";
 export type { HandlerResourceCreateReq } from "./HandlerResourceCreateReq.js";
+export type { HandlerVaultCredentialRevealReq } from "./HandlerVaultCredentialRevealReq.js";
+export type { HandlerVaultCredentialUpdateReq } from "./HandlerVaultCredentialUpdateReq.js";
 export type { ListConnectorsRequest } from "./ListConnectorsRequest.js";
 export type { ListResourcesConnectorsRequest } from "./ListResourcesConnectorsRequest.js";
 export type { PatchConnectorsIdCredentialsRequest } from "./PatchConnectorsIdCredentialsRequest.js";
+export type { PauseConnectorsRequest } from "./PauseConnectorsRequest.js";
+export type { ResumeConnectorsRequest } from "./ResumeConnectorsRequest.js";
 export type { StatusConnectorsRequest } from "./StatusConnectorsRequest.js";
 export type { SyncConnectorsRequest } from "./SyncConnectorsRequest.js";
+export type { UpdateResourceAclConnectorsRequest } from "./UpdateResourceAclConnectorsRequest.js";