@hydradb/sdk 2.1.2 → 2.1.3

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.
+     *
+     * @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,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,
@@ -959,6 +973,68 @@ 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.
+     *
+     * @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 +1073,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 +1088,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

@@ -20,21 +20,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,14 @@
+/**
+ * @example
+ *     {
+ *         id: "HydraDoc1234"
+ *     }
+ */
+export interface HandlerConnectorUpdateReq {
+    /** Connector ID */
+    id: string;
+    /** Provider-specific credentials (typically `{"api_token": "..."}` or `{"access_token": "..."}`). */
+    credentials?: Record<string, unknown>;
+    /** 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,7 +8,7 @@
 export interface HandlerResourceCreateReq {
     /** Connector ID */
     id: string;
-    /** Key-value pairs merged into document metadata on every synced object from this resource. */
+    /** 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;
     databaseOverride?: string;
@@ -16,7 +16,7 @@ export interface HandlerResourceCreateReq {
     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;
+}

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

@@ -4,9 +4,11 @@ export type { DiscoverConnectorsRequest } from "./DiscoverConnectorsRequest.js";
 export type { GetConnectorsRequest } from "./GetConnectorsRequest.js";
 export type { HandlerConfigureReq } from "./HandlerConfigureReq.js";
 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 { ListConnectorsRequest } from "./ListConnectorsRequest.js";
 export type { ListResourcesConnectorsRequest } from "./ListResourcesConnectorsRequest.js";
 export type { PatchConnectorsIdCredentialsRequest } from "./PatchConnectorsIdCredentialsRequest.js";
+export type { StatusConnectorsRequest } from "./StatusConnectorsRequest.js";
 export type { SyncConnectorsRequest } from "./SyncConnectorsRequest.js";

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

@@ -13,10 +13,27 @@ export declare class ContextClient {
     /**
      * Delete one or more knowledge sources or memories by ID.
      *
+     * By default this endpoint answers 200 for every outcome, including a delete
+     * that removed nothing — check `data.deleted_count` and `data.results` rather
+     * than the status code.
+     *
+     * Send `X-HydraDB-Delete-Status: strict` to opt in to honest status codes: a
+     * delete that did not happen then answers 404/409/500 and never 200. This is
+     * the recommended mode for new integrations. On those failures the response
+     * `data` still carries the same `results` / `deleted_count` payload a 200
+     * carries, so per-id outcomes stay readable either way.
+     *
+     * The default is expected to become strict in a future release, at which
+     * point `X-HydraDB-Delete-Status: legacy` keeps the unconditional 200 for a
+     * caller that is not ready.
+     *
      * @param {HydraDB.SourcesV2SourceDeleteRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.ConflictError}
+     * @throws {@link HydraDB.InternalServerError}
      *
      * @example
      *     await client.context.delete()
@@ -40,7 +57,7 @@ export declare class ContextClient {
      *         database: "database"
      *     })
      */
-    ingest(request: HydraDB.IngestContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeIngestionV2SourceUploadResponse>;
+    ingest(request: HydraDB.IngestContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeIngestionV2IngestResponse>;
     private __ingest;
     /**
      * Fetch a previously ingested source's content, inferred content, and a downloadable URL.
@@ -74,7 +91,7 @@ export declare class ContextClient {
      * @example
      *     await client.context.list()
      */
-    list(request?: HydraDB.ListV2ListContentRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeListV2SourceListResponse>;
+    list(request?: HydraDB.ListV2ListContentRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeListV2ListResponse>;
     private __list;
     /**
      * Return knowledge-graph relations for a tenant or a single source.