@hydradb/sdk 2.0.0 → 2.1.0

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

@@ -48,16 +48,81 @@ class ContextClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {HydraDB.BodyIngestContextIngestPost} request
+     * Delete one or more knowledge sources or memories by ID.
+     *
+     * @param {HydraDB.SourcesV2SourceDeleteRequest} request
+     * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     *
+     * @example
+     *     await client.context.delete()
+     */
+    delete(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__delete(request, requestOptions));
+    }
+    async __delete(request = {}, 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, "context"),
+            method: "DELETE",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.SourcesV2SourceDeleteRequest.jsonOrThrow(request, {
+                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.HandlerEnvelopeSourcesMemoryDeleteResponse.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);
+                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", "/context");
+    }
+    /**
+     * Ingest knowledge documents or memories for a tenant.
+     *
+     * @param {HydraDB.IngestContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
-     * @throws {@link HydraDB.NotFoundError}
      * @throws {@link HydraDB.UnprocessableEntityError}
-     * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
      *     import { createReadStream } from "fs";
@@ -70,33 +135,31 @@ class ContextClient {
     }
     async __ingest(request, requestOptions) {
         const _body = await core.newFormData();
-        if (request.type != null) {
-            _body.append("type", serializers.IngestType.jsonOrThrow(request.type, {
-                unrecognizedObjectKeys: "strip",
-                omitUndefined: true,
-            }));
-        }
-        _body.append("tenant_id", request.tenantId);
-        if (request.subTenantId != null) {
-            _body.append("sub_tenant_id", request.subTenantId);
-        }
-        if (request.upsert != null) {
-            _body.append("upsert", request.upsert?.toString());
-        }
-        if (request.documents != null) {
-            for (const _file of request.documents) {
-                await _body.appendFile("documents", _file);
-            }
+        if (request.appKnowledge != null) {
+            _body.append("app_knowledge", request.appKnowledge);
         }
         if (request.documentMetadata != null) {
             _body.append("document_metadata", request.documentMetadata);
         }
-        if (request.appKnowledge != null) {
-            _body.append("app_knowledge", request.appKnowledge);
+        if (request.documents != null) {
+            await _body.appendFile("documents", request.documents);
+        }
+        if (request.graphPayload != null) {
+            _body.append("graph_payload", request.graphPayload);
         }
         if (request.memories != null) {
             _body.append("memories", request.memories);
         }
+        if (request.subTenantId != null) {
+            _body.append("sub_tenant_id", request.subTenantId);
+        }
+        _body.append("tenant_id", request.tenantId);
+        if (request.type != null) {
+            _body.append("type", request.type);
+        }
+        if (request.upsert != null) {
+            _body.append("upsert", request.upsert);
+        }
         const _maybeEncodedRequest = await _body.getRequest();
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({
@@ -106,7 +169,7 @@ class ContextClient {
         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.HydradDb, "context/ingest"),
+                environments.HydraDBEnvironment.Default, "context/ingest"),
             method: "POST",
             headers: _headers,
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
@@ -121,7 +184,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SourceIngestApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeIngestionV2SourceUploadResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -134,19 +197,21 @@ class ContextClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.UnprocessableEntityError(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,
@@ -158,39 +223,39 @@ class ContextClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/context/ingest");
     }
     /**
-     * @param {HydraDB.StatusContextRequest} request
+     * Fetch a previously ingested source's content, inferred content, and a downloadable URL.
+     *
+     * @param {HydraDB.InspectContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
      * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
-     * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.context.status({
-     *         tenantId: "tenant_1234"
+     *     await client.context.inspect({
+     *         id: "id",
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
-    status(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__status(request, requestOptions));
+    inspect(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__inspect(request, requestOptions));
     }
-    async __status(request = {}, requestOptions) {
-        const { id, ids, tenantId, subTenantId } = request;
+    async __inspect(request, requestOptions) {
+        const { id, tenantId, subTenantId, expirySeconds, mode } = request;
         const _queryParams = {
             id,
-            ids,
             tenant_id: tenantId,
             sub_tenant_id: subTenantId,
+            expiry_seconds: expirySeconds,
+            mode,
         };
         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.HydradDb, "context/status"),
+                environments.HydraDBEnvironment.Default, "context/inspect"),
             method: "GET",
             headers: _headers,
             queryString: core.url
@@ -206,7 +271,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SourceStatusApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeFetchV2SourceFetchResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -219,19 +284,21 @@ class ContextClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
+                    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 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.NotFoundError(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,
@@ -240,52 +307,38 @@ class ContextClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/status");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/inspect");
     }
     /**
-     * @param {HydraDB.InspectContextRequest} request
+     * List knowledge sources or memories (id + metadata) for a tenant.
+     *
+     * @param {HydraDB.ListV2ListContentRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
-     * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
-     * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.context.inspect({
-     *         id: "HydraDoc1234",
-     *         tenantId: "tenant_1234",
-     *         mode: "<str>"
-     *     })
+     *     await client.context.list()
      */
-    inspect(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__inspect(request, requestOptions));
+    list(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
     }
-    async __inspect(request, requestOptions) {
-        const { id, tenantId, subTenantId, mode, expirySeconds } = request;
-        const _queryParams = {
-            id,
-            tenant_id: tenantId,
-            sub_tenant_id: subTenantId,
-            mode,
-            expiry_seconds: expirySeconds,
-        };
+    async __list(request = {}, 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.HydradDb, "context/inspect"),
-            method: "GET",
+                environments.HydraDBEnvironment.Default, "context/list"),
+            method: "POST",
             headers: _headers,
-            queryString: core.url
-                .queryBuilder()
-                .addMany(_queryParams)
-                .mergeAdditional(requestOptions?.queryParams)
-                .build(),
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: serializers.ListV2ListContentRequest.jsonOrThrow(request, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }),
             timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
             maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
             abortSignal: requestOptions?.abortSignal,
@@ -294,7 +347,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SourceFetchApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeListV2SourceListResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -307,19 +360,13 @@ class ContextClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(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,
@@ -328,44 +375,48 @@ class ContextClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/inspect");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/context/list");
     }
     /**
-     * @param {HydraDB.V2ListContentRequest} request
+     * Return knowledge-graph relations for a tenant or a single source.
+     *
+     * @param {HydraDB.RelationsContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
-     * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
-     * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.context.list({
-     *         tenantId: "tenant_1234"
+     *     await client.context.relations({
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
-    list(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    relations(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__relations(request, requestOptions));
     }
-    async __list(request, requestOptions) {
+    async __relations(request, requestOptions) {
+        const { tenantId, subTenantId, id, type: type_, limit, cursor } = request;
+        const _queryParams = {
+            tenant_id: tenantId,
+            sub_tenant_id: subTenantId,
+            id,
+            type: type_,
+            limit,
+            cursor,
+        };
         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.HydradDb, "context/list"),
-            method: "POST",
+                environments.HydraDBEnvironment.Default, "context/relations"),
+            method: "GET",
             headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: serializers.V2ListContentRequest.jsonOrThrow(request, {
-                unrecognizedObjectKeys: "strip",
-                omitUndefined: true,
-            }),
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
             timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
             maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
             abortSignal: requestOptions?.abortSignal,
@@ -374,7 +425,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SourceListApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeGraphGraphRelationsResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -387,19 +438,13 @@ class ContextClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(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,
@@ -408,42 +453,40 @@ class ContextClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/context/list");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/relations");
     }
     /**
-     * @param {HydraDB.V2SourceDeleteRequest} request
+     * Merge/upsert tenant_metadata and additional_metadata for one source. sub_tenant_id is required.
+     *
+     * @param {HydraDB.HandlerContextMetadataUpdateRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
      * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.context.delete({
-     *         tenantId: "tenant_1234",
-     *         ids: ["HydraDoc1234", "HydraDoc4567"]
+     *     await client.context.updateSourceMetadata({
+     *         sourceId: "HydraDoc1234"
      *     })
      */
-    delete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__delete(request, requestOptions));
+    updateSourceMetadata(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__updateSourceMetadata(request, requestOptions));
     }
-    async __delete(request, requestOptions) {
+    async __updateSourceMetadata(request, requestOptions) {
+        const { sourceId, ..._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.HydradDb, "context"),
-            method: "DELETE",
+                environments.HydraDBEnvironment.Default, `context/sources/${core.url.encodePathParam(sourceId)}/metadata`),
+            method: "PATCH",
             headers: _headers,
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: serializers.V2SourceDeleteRequest.jsonOrThrow(request, {
+            body: serializers.HandlerContextMetadataUpdateRequest.jsonOrThrow(_body, {
                 unrecognizedObjectKeys: "strip",
                 omitUndefined: true,
             }),
@@ -455,7 +498,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SourceDeleteApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeGithubComHydradbHydradbApplicationInternalServiceMetadataEditResult.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -468,19 +511,29 @@ class ContextClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
+                    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 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.NotFoundError(serializers.HandlerErrorResponse.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.InternalServerError(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,
@@ -489,49 +542,39 @@ class ContextClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "DELETE", "/context");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "PATCH", "/context/sources/{source_id}/metadata");
     }
     /**
-     * @param {HydraDB.RelationsContextRequest} request
+     * Return the processing status for one or more source IDs.
+     *
+     * @param {HydraDB.StatusContextRequest} request
      * @param {ContextClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link HydraDB.BadRequestError}
-     * @throws {@link HydraDB.UnauthorizedError}
-     * @throws {@link HydraDB.ForbiddenError}
-     * @throws {@link HydraDB.NotFoundError}
-     * @throws {@link HydraDB.UnprocessableEntityError}
-     * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.context.relations({
-     *         tenantId: "tenant_1234"
+     *     await client.context.status({
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
-    relations(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__relations(request, requestOptions));
+    status(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__status(request, requestOptions));
     }
-    async __relations(request, requestOptions) {
-        const { tenantId, id, type: type_, subTenantId, limit, cursor } = request;
+    async __status(request, requestOptions) {
+        const { id, ids, tenantId, subTenantId } = request;
         const _queryParams = {
-            tenant_id: tenantId,
             id,
-            type: type_ != null
-                ? serializers.IngestType.jsonOrThrow(type_, {
-                    unrecognizedObjectKeys: "strip",
-                    omitUndefined: true,
-                })
-                : undefined,
+            ids,
+            tenant_id: tenantId,
             sub_tenant_id: subTenantId,
-            limit,
-            cursor,
         };
         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.HydradDb, "context/relations"),
+                environments.HydraDBEnvironment.Default, "context/status"),
             method: "GET",
             headers: _headers,
             queryString: core.url
@@ -547,7 +590,7 @@ class ContextClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SourceRelationsApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeIngestionV2BatchProcessingStatus.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -560,19 +603,13 @@ class ContextClient {
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
                 case 400:
-                    throw new HydraDB.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new HydraDB.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new HydraDB.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new HydraDB.NotFoundError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new HydraDB.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new HydraDB.InternalServerError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new HydraDB.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    throw new HydraDB.BadRequestError(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,
@@ -581,7 +618,7 @@ class ContextClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/relations");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/context/status");
     }
 }
 exports.ContextClient = ContextClient;