@hydradb/sdk 2.1.2 → 2.1.4

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

@@ -100,7 +100,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.discoverPreview.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerDiscoverResponseBody.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -180,7 +180,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.list.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorListResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -193,13 +193,7 @@ class ConnectorsClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -252,7 +246,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.ConnectorsConnector.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorCreateResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -273,13 +267,7 @@ class ConnectorsClient {
                         breadcrumbsPrefix: ["response"],
                     }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 case 503:
                     throw new HydraDB.ServiceUnavailableError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
                         unrecognizedObjectKeys: "passthrough",
@@ -334,7 +322,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.ConnectorsConnector.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorApiView.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -349,13 +337,7 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -402,7 +384,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.delete.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorDeleteResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -417,13 +399,84 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                    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, "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. `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.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.update({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    update(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__update(request, requestOptions));
+    }
+    async __update(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, `connectors/${core.url.encodePathParam(id)}`),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.HandlerConnectorUpdateReq.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.HandlerConnectorUpdateResponse.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,
@@ -432,7 +485,7 @@ class ConnectorsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/connectors/{id}");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "PATCH", "/connectors/{id}");
     }
     /**
      * Save the selected resources for a connector and trigger initial sync/backfill.
@@ -492,7 +545,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.configure.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerConfigureResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -515,13 +568,7 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -533,7 +580,7 @@ class ConnectorsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/connectors/{id}/configure");
     }
     /**
-     * Internal-service endpoint (X-Cortex-Secret) used by the MOVEIT refresh loop to persist a rotated refresh_token for OAuth-bundle connectors. Providers that rotate the refresh token on each exchange invalidate the previously stored one, so the new token must be written back or the next sync fails with invalid_grant. Only refresh_token is merged onto the current stored credential bundle and re-encrypted under the connector's identity context; credentials are never returned.
+     * Internal endpoint. It is not callable with a customer API key and always returns 403 for external callers. Persists a rotated refresh_token for OAuth-bundle connectors: providers that rotate the refresh token on each exchange invalidate the previously stored one, so the new token must be written back or the next sync fails with invalid_grant. Only refresh_token is merged onto the current stored credential bundle and re-encrypted under the connector's identity context; credentials are never returned. It has no automated caller and is disabled by default: until an operator enables it, every call returns 500.
      *
      * @param {HydraDB.PatchConnectorsIdCredentialsRequest} request
      * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -545,17 +592,17 @@ class ConnectorsClient {
      * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.connectors.rotateAConnectorsStoredOAuthRefreshToken({
+     *     await client.connectors.rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly({
      *         id: "HydraDoc1234",
      *         body: {
      *             "key": "value"
      *         }
      *     })
      */
-    rotateAConnectorsStoredOAuthRefreshToken(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__rotateAConnectorsStoredOAuthRefreshToken(request, requestOptions));
+    rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly(request, requestOptions));
     }
-    async __rotateAConnectorsStoredOAuthRefreshToken(request, requestOptions) {
+    async __rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly(request, requestOptions) {
         const { id, body: _body } = request;
         const _headers = (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "API-Version": requestOptions?.apiVersion ?? this._options?.apiVersion ?? "2" }), requestOptions?.headers);
         const _response = await core.fetcher({
@@ -567,10 +614,7 @@ class ConnectorsClient {
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: serializers.connectors.rotateAConnectorsStoredOAuthRefreshToken.Request.jsonOrThrow(_body, {
-                unrecognizedObjectKeys: "strip",
-                omitUndefined: true,
-            }),
+            body: serializers.connectors.rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly.Request.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip", omitUndefined: true }),
             timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
             maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
             abortSignal: requestOptions?.abortSignal,
@@ -579,7 +623,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.rotateAConnectorsStoredOAuthRefreshToken.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerCredentialsUpdateResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -610,13 +654,7 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 case 503:
                     throw new HydraDB.ServiceUnavailableError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
                         unrecognizedObjectKeys: "passthrough",
@@ -681,7 +719,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.discover.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerDiscoverResponseBody.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -704,13 +742,7 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 case 502:
                     throw new HydraDB.BadGatewayError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
                         unrecognizedObjectKeys: "passthrough",
@@ -765,7 +797,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.listResources.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorResourcesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -780,13 +812,7 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -864,13 +890,7 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.HydraDBError({
                         statusCode: _response.error.statusCode,
@@ -919,7 +939,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.deleteResource.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerResourceDeleteResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -942,13 +962,88 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                    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, "DELETE", "/connectors/{id}/resources/{resource_id}");
+    }
+    /**
+     * 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,
@@ -957,7 +1052,69 @@ class ConnectorsClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/connectors/{id}/resources/{resource_id}");
+        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.
+     *
+     * @param {HydraDB.StatusConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.status({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    status(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__status(request, requestOptions));
+    }
+    async __status(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)}/status`),
+            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.HandlerConnectorStatusResponse.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 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, "GET", "/connectors/{id}/status");
     }
     /**
      * Start a manual sync workflow for a connector.
@@ -997,7 +1154,7 @@ class ConnectorsClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.connectors.sync.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorSyncResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1012,21 +1169,9 @@ class ConnectorsClient {
                 case 404:
                     throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
-                    throw new HydraDB.ConflictError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.ConflictError(_response.error.body, _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
                 case 503:
                     throw new HydraDB.ServiceUnavailableError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
                         unrecognizedObjectKeys: "passthrough",

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

@@ -29,4 +29,12 @@ export interface HandlerConfigureReq {
     lookbackDays?: number;
     /** Resources to activate for this connector. Each item corresponds to one entry from the Discover endpoint. */
     resources: HydraDB.HandlerResourceMapping[];
+    /**
+     * TableConfigs carries per-table replication settings for MOVEIT
+     * connectors whose tap reads a `table_configs` credential input (bigquery).
+     * Configure merges them into the stored credential bundle before the first
+     * sync, so the mode chosen at selection time governs every sync from the
+     * start. Optional; rejected for non-MOVEIT engines.
+     */
+    tableConfigs?: HydraDB.HandlerTableConfigEntry[];
 }

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
@@ -20,21 +26,15 @@ export interface HandlerConnectorCreateReq {
      * here would force the generated SDK to demand the deprecated field.
      */
     database?: string;
-    /** Internal deployment context for this connector. */
-    deploymentId?: string;
     /** Human-readable label for this connector. */
     name?: string;
-    /** Subscription plan this connector runs under. */
-    plan?: string;
     /** External provider being synced (e.g. `slack`, `github`, `linear`, `notion`, `gmail`). */
     provider: string;
     /** Identifier for the external account (e.g. Slack workspace ID, GitHub org name). Must be distinct across connectors for the same provider. */
     providerAccountScope?: string;
     /** deprecated: use collection */
     subTenantId?: string;
-    /** SyncEngine selects the sync pipeline: "classic" (default) or "moveit". */
-    syncEngine?: string;
-    /** How frequently the scheduler triggers incremental syncs, in seconds. */
+    /** 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;
     /** deprecated: use database */
     tenantId?: string;

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

@@ -0,0 +1,20 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234"
+ *     }
+ */
+export interface HandlerConnectorUpdateReq {
+    /** Connector ID */
+    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,15 +8,27 @@
 export interface HandlerResourceCreateReq {
     /** Connector ID */
     id: string;
-    /** Key-value pairs merged into document metadata on every synced object from this resource. */
+    /**
+     * 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;
     /** Provider-specific filters applied during sync (e.g. `{"lookback_days": 30}`). */
     filters?: Record<string, unknown>;
-    /** Key-value pairs merged into tenant metadata on every synced object from this resource. */
+    /** Key-value pairs merged into tenant metadata on every synced object from this resource. Capped at 16 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. */
     metadata?: Record<string, unknown>;
     /** Additional provider-supplied metadata for this resource. */
     providerMetadata?: Record<string, unknown>;

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

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