@hydradb/sdk 2.0.0 → 2.1.0

package/dist/Client.d.ts

@@ -1,6 +1,6 @@
 import * as HydraDB from "./api/index.js";
 import { ContextClient } from "./api/resources/context/client/Client.js";
-import { TenantsClient } from "./api/resources/tenants/client/Client.js";
+import { DatabasesClient } from "./api/resources/databases/client/Client.js";
 import { WebhooksClient } from "./api/resources/webhooks/client/Client.js";
 import type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
 import { type NormalizedClientOptionsWithAuth } from "./BaseClient.js";
@@ -12,33 +12,27 @@ export declare namespace HydraDBClient {
 }
 export declare class HydraDBClient {
     protected readonly _options: NormalizedClientOptionsWithAuth<HydraDBClient.Options>;
-    protected _webhooks: WebhooksClient | undefined;
     protected _context: ContextClient | undefined;
-    protected _tenants: TenantsClient | undefined;
+    protected _databases: DatabasesClient | undefined;
+    protected _webhooks: WebhooksClient | undefined;
     constructor(options: HydraDBClient.Options);
-    get webhooks(): WebhooksClient;
     get context(): ContextClient;
-    get tenants(): TenantsClient;
+    get databases(): DatabasesClient;
+    get webhooks(): WebhooksClient;
     /**
-     * @param {HydraDB.QueryRequest} request
+     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids.
+     *
+     * @param {HydraDB.SearchQueryRequest} request
      * @param {HydraDBClient.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.TooManyRequestsError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.query({
-     *         tenantId: "tenant_1234",
-     *         query: "Which mode does user prefer"
-     *     })
+     *     await client.query()
      */
-    query(request: HydraDB.QueryRequest, requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<HydraDB.QueryApiResponse>;
+    query(request?: HydraDB.SearchQueryRequest, requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSearchV2RetrievalResult>;
     private __query;
     /**
      * Make a passthrough request using the SDK's configured auth, retry, logging, etc.

package/dist/Client.js

@@ -37,7 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HydraDBClient = void 0;
 const HydraDB = __importStar(require("./api/index.js"));
 const Client_js_1 = require("./api/resources/context/client/Client.js");
-const Client_js_2 = require("./api/resources/tenants/client/Client.js");
+const Client_js_2 = require("./api/resources/databases/client/Client.js");
 const Client_js_3 = require("./api/resources/webhooks/client/Client.js");
 const BaseClient_js_1 = require("./BaseClient.js");
 const headers_js_1 = require("./core/headers.js");
@@ -50,50 +50,44 @@ class HydraDBClient {
     constructor(options) {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
-    get webhooks() {
-        return (this._webhooks ?? (this._webhooks = new Client_js_3.WebhooksClient(this._options)));
-    }
     get context() {
         return (this._context ?? (this._context = new Client_js_1.ContextClient(this._options)));
     }
-    get tenants() {
-        return (this._tenants ?? (this._tenants = new Client_js_2.TenantsClient(this._options)));
+    get databases() {
+        return (this._databases ?? (this._databases = new Client_js_2.DatabasesClient(this._options)));
+    }
+    get webhooks() {
+        return (this._webhooks ?? (this._webhooks = new Client_js_3.WebhooksClient(this._options)));
     }
     /**
-     * @param {HydraDB.QueryRequest} request
+     * Unified query endpoint that dispatches across type (knowledge/memory/all) and query_by (hybrid/text). Prefer sub_tenant_ids for sub-tenant scoping; legacy sub_tenant_id is deprecated for /query and cannot be sent together with sub_tenant_ids.
+     *
+     * @param {HydraDB.SearchQueryRequest} request
      * @param {HydraDBClient.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.TooManyRequestsError}
      * @throws {@link HydraDB.InternalServerError}
-     * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.query({
-     *         tenantId: "tenant_1234",
-     *         query: "Which mode does user prefer"
-     *     })
+     *     await client.query()
      */
-    query(request, requestOptions) {
+    query(request = {}, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__query(request, requestOptions));
     }
-    async __query(request, requestOptions) {
+    async __query(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, "query"),
+                environments.HydraDBEnvironment.Default, "query"),
             method: "POST",
             headers: _headers,
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: serializers.QueryRequest.jsonOrThrow(request, {
+            body: serializers.SearchQueryRequest.jsonOrThrow(request, {
                 unrecognizedObjectKeys: "strip",
                 omitUndefined: true,
             }),
@@ -105,7 +99,7 @@ class HydraDBClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.QueryApiResponse.parseOrThrow(_response.body, {
+                data: serializers.HandlerEnvelopeSearchV2RetrievalResult.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -118,21 +112,29 @@ class HydraDBClient {
         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 429:
-                    throw new HydraDB.TooManyRequestsError(_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,

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

@@ -0,0 +1,50 @@
+import type * as HydraDB from "../../index.js";
+/**
+ * @example
+ *     {}
+ */
+export interface SearchQueryRequest {
+    additionalContext?: string;
+    alpha?: unknown;
+    collection?: string;
+    /** Preferred /query scope selector. Send either a list of collection IDs for equal normalized weighting, or an object mapping collection ID to a positive relative ranking weight with at most one decimal place. Do not send together with the deprecated sub_tenant_ids or sub_tenant_id. */
+    collections?: HydraDB.SearchQueryRequestCollections;
+    /**
+     * Database is the canonical v2 name for the tenant scope. TenantID is its
+     * deprecated alias and remains fully accepted. The TenantAliases middleware
+     * reconciles the two before binding, so TenantID is always populated and the
+     * handler reads it; Database/Collection are carried only for docs/OpenAPI.
+     */
+    database?: string;
+    /** Whether to include graph context in the response. Defaults to true for /query when omitted. */
+    graphContext?: boolean;
+    /**
+     * IDs optionally scopes retrieval to specific source ids. The v2 wire field is
+     * `ids` (matching /context/list); empty means search the whole corpus. Applied
+     * as a Milvus `source_id in [...]` pre-filter that is preserved across the
+     * metadata zero-result retry, so a source-scoped search that matches nothing
+     * returns nothing rather than silently widening to the whole corpus.
+     */
+    ids?: string[];
+    maxResults?: number;
+    metadataFilters?: HydraDB.SearchMetadataFilters;
+    mode?: HydraDB.SearchRecallMode;
+    numRelatedChunks?: number;
+    operator?: HydraDB.SearchOperator;
+    query?: string;
+    /** Whether to include app-aware knowledge retrieval. Applies to knowledge hybrid queries. */
+    queryApps?: boolean;
+    /** Retrieval method to use for the query. */
+    queryBy?: HydraDB.SearchQueryBy;
+    /** Whether to force relation expansion for graph-aware query retrieval. Defaults to true when omitted. */
+    queryForcefulRelations?: boolean;
+    recencyBias?: number;
+    /** Deprecated for /query (since 2.0.1). Use collection for a single scope or collections for multiple. Backwards-compatible and will be removed in a future version. Do not send together with a multi-scope selector. */
+    subTenantId?: string;
+    /** Deprecated for /query (since 2.0.1). Use collections instead; it accepts the same list or weighted-object shape. Backwards-compatible and will be removed in a future version. Do not send together with collections. */
+    subTenantIds?: HydraDB.SearchQueryRequestSubTenantIds;
+    /** deprecated: use database */
+    tenantId?: string;
+    /** Corpus to query: knowledge, memory, or all. */
+    type?: HydraDB.SearchSourceType;
+}

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

@@ -1 +1 @@
-export type { QueryRequest } from "./QueryRequest.js";
+export type { SearchQueryRequest } from "./SearchQueryRequest.js";

package/dist/api/errors/BadRequestError.d.ts

@@ -1,5 +1,6 @@
 import type * as core from "../../core/index.js";
 import * as errors from "../../errors/index.js";
+import type * as HydraDB from "../index.js";
 export declare class BadRequestError extends errors.HydraDBError {
-    constructor(body?: unknown, rawResponse?: core.RawResponse);
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
 }

package/dist/api/errors/ConflictError.d.ts

@@ -0,0 +1,6 @@
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as HydraDB from "../index.js";
+export declare class ConflictError extends errors.HydraDBError {
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
+}

package/dist/api/errors/{UnauthorizedError.js → ConflictError.js}

@@ -34,13 +34,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnauthorizedError = void 0;
+exports.ConflictError = void 0;
 const errors = __importStar(require("../../errors/index.js"));
-class UnauthorizedError extends errors.HydraDBError {
+class ConflictError extends errors.HydraDBError {
     constructor(body, rawResponse) {
         super({
-            message: "UnauthorizedError",
-            statusCode: 401,
+            message: "ConflictError",
+            statusCode: 409,
             body: body,
             rawResponse: rawResponse,
         });
@@ -51,4 +51,4 @@ class UnauthorizedError extends errors.HydraDBError {
         this.name = this.constructor.name;
     }
 }
-exports.UnauthorizedError = UnauthorizedError;
+exports.ConflictError = ConflictError;

package/dist/api/errors/ForbiddenError.d.ts

@@ -1,5 +1,6 @@
 import type * as core from "../../core/index.js";
 import * as errors from "../../errors/index.js";
+import type * as HydraDB from "../index.js";
 export declare class ForbiddenError extends errors.HydraDBError {
-    constructor(body?: unknown, rawResponse?: core.RawResponse);
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
 }

package/dist/api/errors/InternalServerError.d.ts

@@ -1,5 +1,6 @@
 import type * as core from "../../core/index.js";
 import * as errors from "../../errors/index.js";
+import type * as HydraDB from "../index.js";
 export declare class InternalServerError extends errors.HydraDBError {
-    constructor(body?: unknown, rawResponse?: core.RawResponse);
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
 }

package/dist/api/errors/NotFoundError.d.ts

@@ -1,5 +1,6 @@
 import type * as core from "../../core/index.js";
 import * as errors from "../../errors/index.js";
+import type * as HydraDB from "../index.js";
 export declare class NotFoundError extends errors.HydraDBError {
-    constructor(body?: unknown, rawResponse?: core.RawResponse);
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
 }

package/dist/api/errors/UnprocessableEntityError.d.ts

@@ -1,5 +1,6 @@
 import type * as core from "../../core/index.js";
 import * as errors from "../../errors/index.js";
+import type * as HydraDB from "../index.js";
 export declare class UnprocessableEntityError extends errors.HydraDBError {
-    constructor(body?: unknown, rawResponse?: core.RawResponse);
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
 }

package/dist/api/errors/index.d.ts

@@ -1,8 +1,6 @@
 export * from "./BadRequestError.js";
+export * from "./ConflictError.js";
 export * from "./ForbiddenError.js";
 export * from "./InternalServerError.js";
 export * from "./NotFoundError.js";
-export * from "./ServiceUnavailableError.js";
-export * from "./TooManyRequestsError.js";
-export * from "./UnauthorizedError.js";
 export * from "./UnprocessableEntityError.js";

package/dist/api/errors/index.js

@@ -15,10 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./BadRequestError.js"), exports);
+__exportStar(require("./ConflictError.js"), exports);
 __exportStar(require("./ForbiddenError.js"), exports);
 __exportStar(require("./InternalServerError.js"), exports);
 __exportStar(require("./NotFoundError.js"), exports);
-__exportStar(require("./ServiceUnavailableError.js"), exports);
-__exportStar(require("./TooManyRequestsError.js"), exports);
-__exportStar(require("./UnauthorizedError.js"), exports);
 __exportStar(require("./UnprocessableEntityError.js"), exports);

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

@@ -11,121 +11,113 @@ export declare class ContextClient {
     protected readonly _options: NormalizedClientOptionsWithAuth<ContextClient.Options>;
     constructor(options: ContextClient.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}
-     * @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";
-     *     await client.context.ingest({
-     *         tenantId: "tenant_id"
-     *     })
+     *     await client.context.delete()
      */
-    ingest(request: HydraDB.BodyIngestContextIngestPost, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.SourceIngestApiResponse>;
-    private __ingest;
+    delete(request?: HydraDB.SourcesV2SourceDeleteRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeSourcesMemoryDeleteResponse>;
+    private __delete;
     /**
-     * @param {HydraDB.StatusContextRequest} request
+     * 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
-     *     await client.context.status({
-     *         tenantId: "tenant_1234"
+     *     import { createReadStream } from "fs";
+     *     await client.context.ingest({
+     *         tenantId: "tenant_id"
      *     })
      */
-    status(request?: HydraDB.StatusContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.SourceStatusApiResponse>;
-    private __status;
+    ingest(request: HydraDB.IngestContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeIngestionV2SourceUploadResponse>;
+    private __ingest;
     /**
+     * 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.inspect({
-     *         id: "HydraDoc1234",
+     *         id: "id",
      *         tenantId: "tenant_1234",
-     *         mode: "<str>"
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
-    inspect(request: HydraDB.InspectContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.SourceFetchApiResponse>;
+    inspect(request: HydraDB.InspectContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeFetchV2SourceFetchResponse>;
     private __inspect;
     /**
-     * @param {HydraDB.V2ListContentRequest} 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.list({
-     *         tenantId: "tenant_1234"
-     *     })
+     *     await client.context.list()
      */
-    list(request: HydraDB.V2ListContentRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.SourceListApiResponse>;
+    list(request?: HydraDB.ListV2ListContentRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeListV2SourceListResponse>;
     private __list;
     /**
-     * @param {HydraDB.V2SourceDeleteRequest} 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.delete({
+     *     await client.context.relations({
      *         tenantId: "tenant_1234",
-     *         ids: ["HydraDoc1234", "HydraDoc4567"]
+     *         subTenantId: "sub_tenant_4567"
      *     })
      */
-    delete(request: HydraDB.V2SourceDeleteRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.SourceDeleteApiResponse>;
-    private __delete;
+    relations(request: HydraDB.RelationsContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeGraphGraphRelationsResponse>;
+    private __relations;
     /**
-     * @param {HydraDB.RelationsContextRequest} 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.relations({
-     *         tenantId: "tenant_1234"
+     *     await client.context.updateSourceMetadata({
+     *         sourceId: "HydraDoc1234"
      *     })
      */
-    relations(request: HydraDB.RelationsContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.SourceRelationsApiResponse>;
-    private __relations;
+    updateSourceMetadata(request: HydraDB.HandlerContextMetadataUpdateRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeGithubComHydradbHydradbApplicationInternalServiceMetadataEditResult>;
+    private __updateSourceMetadata;
+    /**
+     * 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}
+     *
+     * @example
+     *     await client.context.status({
+     *         tenantId: "tenant_1234",
+     *         subTenantId: "sub_tenant_4567"
+     *     })
+     */
+    status(request: HydraDB.StatusContextRequest, requestOptions?: ContextClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerEnvelopeIngestionV2BatchProcessingStatus>;
+    private __status;
 }