@hydradb/sdk 2.1.1 → 2.1.3

package/dist/Client.d.ts

@@ -2,6 +2,7 @@ import * as HydraDB from "./api/index.js";
 import { ConnectorsClient } from "./api/resources/connectors/client/Client.js";
 import { ContextClient } from "./api/resources/context/client/Client.js";
 import { DatabasesClient } from "./api/resources/databases/client/Client.js";
+import { FeedbackClient } from "./api/resources/feedback/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";
@@ -16,11 +17,13 @@ export declare class HydraDBClient {
     protected _connectors: ConnectorsClient | undefined;
     protected _context: ContextClient | undefined;
     protected _databases: DatabasesClient | undefined;
+    protected _feedback: FeedbackClient | undefined;
     protected _webhooks: WebhooksClient | undefined;
     constructor(options?: HydraDBClient.Options);
     get connectors(): ConnectorsClient;
     get context(): ContextClient;
     get databases(): DatabasesClient;
+    get feedback(): FeedbackClient;
     get webhooks(): WebhooksClient;
     /**
      * List every provider in the supported_connectors control-plane table (availability, sync engine, maturity, category) for the dashboard connector catalog.
@@ -30,10 +33,10 @@ export declare class HydraDBClient {
      * @example
      *     await client.catalog()
      */
-    catalog(requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    catalog(requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorCatalogResponse>;
     private __catalog;
     /**
-     * Without ?id: returns every supported connector with its availability, maturity, category, and sync engine (the connector catalog). With ?id=<provider>: returns what that provider stores and how to use it — indexed_object_types (the streams that become searchable documents), searchable_fields (rendered into the indexed text), filterable_fields (each with the exact filter_key to pass in a query's metadata_filters), and the credential_schema for connecting it.
+     * Without ?id: returns every supported connector with its availability, maturity, category, and sync engine (the connector catalog). With ?id=<provider>: returns what that provider stores and how to use it — indexed_object_types (the streams that become searchable documents), searchable_fields (rendered into the indexed text), filterable_fields (each with the exact filter_key to pass in a query's metadata_filters), the credential_schema for connecting it, and setup_guide (present for providers whose configuration goes beyond the credential schema — e.g. bigquery's per-table cursor/change-history settings and the one-time ALTER statement they may require).
      *
      * @param {HydraDB.ListProvidersRequest} request
      * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -45,7 +48,7 @@ export declare class HydraDBClient {
      *         id: "HydraDoc1234"
      *     })
      */
-    listProviders(request?: HydraDB.ListProvidersRequest, requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    listProviders(request?: HydraDB.ListProvidersRequest, requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerProviderListResponse>;
     private __listProviders;
     /**
      * 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.

package/dist/Client.js

@@ -39,7 +39,8 @@ const HydraDB = __importStar(require("./api/index.js"));
 const Client_js_1 = require("./api/resources/connectors/client/Client.js");
 const Client_js_2 = require("./api/resources/context/client/Client.js");
 const Client_js_3 = require("./api/resources/databases/client/Client.js");
-const Client_js_4 = require("./api/resources/webhooks/client/Client.js");
+const Client_js_4 = require("./api/resources/feedback/client/Client.js");
+const Client_js_5 = require("./api/resources/webhooks/client/Client.js");
 const BaseClient_js_1 = require("./BaseClient.js");
 const headers_js_1 = require("./core/headers.js");
 const core = __importStar(require("./core/index.js"));
@@ -60,8 +61,11 @@ class HydraDBClient {
     get databases() {
         return (this._databases ?? (this._databases = new Client_js_3.DatabasesClient(this._options)));
     }
+    get feedback() {
+        return (this._feedback ?? (this._feedback = new Client_js_4.FeedbackClient(this._options)));
+    }
     get webhooks() {
-        return (this._webhooks ?? (this._webhooks = new Client_js_4.WebhooksClient(this._options)));
+        return (this._webhooks ?? (this._webhooks = new Client_js_5.WebhooksClient(this._options)));
     }
     /**
      * List every provider in the supported_connectors control-plane table (availability, sync engine, maturity, category) for the dashboard connector catalog.
@@ -91,7 +95,7 @@ class HydraDBClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.catalog.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerConnectorCatalogResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -111,7 +115,7 @@ class HydraDBClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "GET", "/connector-catalog");
     }
     /**
-     * Without ?id: returns every supported connector with its availability, maturity, category, and sync engine (the connector catalog). With ?id=<provider>: returns what that provider stores and how to use it — indexed_object_types (the streams that become searchable documents), searchable_fields (rendered into the indexed text), filterable_fields (each with the exact filter_key to pass in a query's metadata_filters), and the credential_schema for connecting it.
+     * Without ?id: returns every supported connector with its availability, maturity, category, and sync engine (the connector catalog). With ?id=<provider>: returns what that provider stores and how to use it — indexed_object_types (the streams that become searchable documents), searchable_fields (rendered into the indexed text), filterable_fields (each with the exact filter_key to pass in a query's metadata_filters), the credential_schema for connecting it, and setup_guide (present for providers whose configuration goes beyond the credential schema — e.g. bigquery's per-table cursor/change-history settings and the one-time ALTER statement they may require).
      *
      * @param {HydraDB.ListProvidersRequest} request
      * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -151,7 +155,7 @@ class HydraDBClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.listProviders.Response.parseOrThrow(_response.body, {
+                data: serializers.HandlerProviderListResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -238,13 +242,7 @@ class HydraDBClient {
                 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,

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

@@ -72,6 +72,26 @@ export interface SearchQueryRequest {
     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;
+    temporalIntent?: HydraDB.SearchTemporalIntentOverride;
+    /**
+     * TemporalNow optionally anchors "now" for temporal reasoning (ISO-8601).
+     * Callers replaying past conversations (or backfilling) must supply it or
+     * to-now durations and recency windows resolve against the server's wall
+     * clock (LongMemEval measured 0 exact to-now durations from this alone).
+     */
+    temporalNow?: string;
+    /**
+     * TemporalReasoning activates the temporal read path: the query is classified
+     * into a temporal mode (current/as-of/range/upcoming...), matching edge-level
+     * temporal facts are resolved from the edge_temporal store and ride back on
+     * the response (temporal_facts / temporal_duration / temporal_filter).
+     * CONTRACT: chunk ranking is NEVER altered — ON returns the same chunks as
+     * OFF; the layer is additive payload + computed answers only (rank shaping
+     * measured net-negative on BEAM/LongMemEval/TEMPO; see temporal_filters.go).
+     * Optional; ON by default — pass temporal_reasoning:false to disable.
+     * Resolved by GetTemporalReasoningOrDefault (ownership rule).
+     */
+    temporalReasoning?: boolean;
     /** deprecated: use database */
     tenantId?: string;
     /** Corpus to query: knowledge, memory, or all. */

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

@@ -1,6 +1,5 @@
 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);
+    constructor(body?: unknown, rawResponse?: core.RawResponse);
 }

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

@@ -1,6 +1,5 @@
 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: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
+    constructor(body?: unknown, rawResponse?: core.RawResponse);
 }

package/dist/api/errors/UnsupportedMediaTypeError.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 UnsupportedMediaTypeError extends errors.HydraDBError {
+    constructor(body: HydraDB.HandlerErrorResponse, rawResponse?: core.RawResponse);
+}

package/dist/api/errors/UnsupportedMediaTypeError.js

@@ -0,0 +1,54 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedMediaTypeError = void 0;
+const errors = __importStar(require("../../errors/index.js"));
+class UnsupportedMediaTypeError extends errors.HydraDBError {
+    constructor(body, rawResponse) {
+        super({
+            message: "UnsupportedMediaTypeError",
+            statusCode: 415,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = this.constructor.name;
+    }
+}
+exports.UnsupportedMediaTypeError = UnsupportedMediaTypeError;

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

@@ -7,3 +7,4 @@ export * from "./InternalServerError.js";
 export * from "./NotFoundError.js";
 export * from "./ServiceUnavailableError.js";
 export * from "./UnprocessableEntityError.js";
+export * from "./UnsupportedMediaTypeError.js";

package/dist/api/errors/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./InternalServerError.js"), exports);
 __exportStar(require("./NotFoundError.js"), exports);
 __exportStar(require("./ServiceUnavailableError.js"), exports);
 __exportStar(require("./UnprocessableEntityError.js"), exports);
+__exportStar(require("./UnsupportedMediaTypeError.js"), exports);

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

@@ -11,7 +11,7 @@ export declare class ConnectorsClient {
     protected readonly _options: NormalizedClientOptionsWithAuth<ConnectorsClient.Options>;
     constructor(options?: ConnectorsClient.Options);
     /**
-     * List a provider's resources directly from supplied credentials, before creating a connector.
+     * List a provider's resources directly from supplied credentials, before creating a connector. Passing cursor or limit opts into pagination (currently Notion only): the response then adds next_cursor and has_more, a page may hold fewer than limit resources, and clients must continue while has_more is true. Without either param the full resource list is returned.
      *
      * @param {HydraDB.HandlerDiscoverPreviewReq} request
      * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -27,7 +27,7 @@ export declare class ConnectorsClient {
      *         provider: "slack"
      *     })
      */
-    discoverPreview(request: HydraDB.HandlerDiscoverPreviewReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    discoverPreview(request: HydraDB.HandlerDiscoverPreviewReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerDiscoverResponseBody>;
     private __discoverPreview;
     /**
      * List all connectors for the authenticated org, optionally filtered by provider.
@@ -42,7 +42,7 @@ export declare class ConnectorsClient {
      *         provider: "slack"
      *     })
      */
-    list(request?: HydraDB.ListConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    list(request?: HydraDB.ListConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorListResponse>;
     private __list;
     /**
      * Create a connector for a provider and store its credentials.
@@ -59,7 +59,7 @@ export declare class ConnectorsClient {
      *         provider: "slack"
      *     })
      */
-    create(request: HydraDB.HandlerConnectorCreateReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.ConnectorsConnector>;
+    create(request: HydraDB.HandlerConnectorCreateReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorCreateResponse>;
     private __create;
     /**
      * Fetch a single connector by ID.
@@ -75,7 +75,7 @@ export declare class ConnectorsClient {
      *         id: "HydraDoc1234"
      *     })
      */
-    get(request: HydraDB.GetConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.ConnectorsConnector>;
+    get(request: HydraDB.GetConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorApiView>;
     private __get;
     /**
      * Delete a connector, its resources, and stored credentials.
@@ -91,8 +91,25 @@ export declare class ConnectorsClient {
      *         id: "HydraDoc1234"
      *     })
      */
-    delete(request: HydraDB.DeleteConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    delete(request: HydraDB.DeleteConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorDeleteResponse>;
     private __delete;
+    /**
+     * 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: HydraDB.HandlerConnectorUpdateReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorUpdateResponse>;
+    private __update;
     /**
      * Save the selected resources for a connector and trigger initial sync/backfill.
      *
@@ -119,16 +136,14 @@ export declare class ConnectorsClient {
      *                 },
      *                 name: "general",
      *                 resourceId: "C0123456789",
-     *                 resourceType: "channel",
-     *                 subTenantId: "sub_tenant_4567",
-     *                 tenantId: "tenant_1234"
+     *                 resourceType: "channel"
      *             }]
      *     })
      */
-    configure(request: HydraDB.HandlerConfigureReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    configure(request: HydraDB.HandlerConfigureReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConfigureResponse>;
     private __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.
@@ -140,17 +155,17 @@ export declare class ConnectorsClient {
      * @throws {@link HydraDB.ServiceUnavailableError}
      *
      * @example
-     *     await client.connectors.rotateAConnectorsStoredOAuthRefreshToken({
+     *     await client.connectors.rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly({
      *         id: "HydraDoc1234",
      *         body: {
      *             "key": "value"
      *         }
      *     })
      */
-    rotateAConnectorsStoredOAuthRefreshToken(request: HydraDB.PatchConnectorsIdCredentialsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
-    private __rotateAConnectorsStoredOAuthRefreshToken;
+    rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly(request: HydraDB.PatchConnectorsIdCredentialsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerCredentialsUpdateResponse>;
+    private __rotateAConnectorsStoredOAuthRefreshTokenInternalUseOnly;
     /**
-     * List a connected provider's resources using the connector's stored credentials.
+     * List a connected provider's resources using the connector's stored credentials. Passing cursor or limit opts into pagination (currently Notion only): the response then adds next_cursor and has_more, a page may hold fewer than limit resources, and clients must continue while has_more is true. Without either param the full resource list is returned.
      *
      * @param {HydraDB.DiscoverConnectorsRequest} request
      * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -165,7 +180,7 @@ export declare class ConnectorsClient {
      *         id: "HydraDoc1234"
      *     })
      */
-    discover(request: HydraDB.DiscoverConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    discover(request: HydraDB.DiscoverConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerDiscoverResponseBody>;
     private __discover;
     /**
      * List the configured resources for a connector.
@@ -181,7 +196,7 @@ export declare class ConnectorsClient {
      *         id: "HydraDoc1234"
      *     })
      */
-    listResources(request: HydraDB.ListResourcesConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    listResources(request: HydraDB.ListResourcesConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorResourcesResponse>;
     private __listResources;
     /**
      * Add a resource mapping to a connector.
@@ -217,8 +232,24 @@ export declare class ConnectorsClient {
      *         resourceId: "C0123456789"
      *     })
      */
-    deleteResource(request: HydraDB.DeleteResourceConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    deleteResource(request: HydraDB.DeleteResourceConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerResourceDeleteResponse>;
     private __deleteResource;
+    /**
+     * 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: HydraDB.StatusConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorStatusResponse>;
+    private __status;
     /**
      * Start a manual sync workflow for a connector.
      *
@@ -235,6 +266,6 @@ export declare class ConnectorsClient {
      *         id: "HydraDoc1234"
      *     })
      */
-    sync(request: HydraDB.SyncConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    sync(request: HydraDB.SyncConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorSyncResponse>;
     private __sync;
 }