@hydradb/sdk 2.1.2 → 2.1.4

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,7 +33,7 @@ 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), 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).
@@ -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,
@@ -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

@@ -4,6 +4,18 @@ import type * as HydraDB from "../../index.js";
  *     {}
  */
 export interface SearchQueryRequest {
+    /**
+     * ACL scopes retrieval to documents the given principals may access
+     * (PRO-1684 document ACLs): a document matches when its stored ACL is
+     * empty (unrestricted, pre-RBAC content and connectors without permission
+     * support), contains __public__, or intersects these principals. Entries
+     * are bare emails or prefixed principals (user_email:/group:/domain:).
+     * Omitted, empty, or ["*"] disables ACL filtering entirely, today's
+     * behavior. Like IDs, the resulting clause survives the metadata
+     * zero-result retry. An entry that is not a known principal fails CLOSED:
+     * it matches only public and unrestricted documents, never restricted.
+     */
+    acl?: string[];
     /** Optional context string prepended to the query to improve retrieval relevance. */
     additionalContext?: string;
     /** Weighting balance between dense and sparse retrieval in hybrid mode. `"auto"` lets HydraDB choose; a number from 0 (full BM25) to 1 (full dense) sets it explicitly. */
@@ -72,6 +84,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/resources/connectors/client/Client.d.ts

@@ -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. `custom_instructions` replaces the free-text steering applied when this connector's documents are ingested (an explicit empty string clears it); the change applies from the next sync cycle and does not re-process already-ingested documents. When several fields are supplied together they are validated up front and applied atomically: an invalid value rejects the whole request with nothing changed.
+     *
+     * @param {HydraDB.HandlerConnectorUpdateReq} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.update({
+     *         id: "HydraDoc1234"
+     *     })
+     */
+    update(request: HydraDB.HandlerConnectorUpdateReq, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerConnectorUpdateResponse>;
+    private __update;
     /**
      * Save the selected resources for a connector and trigger initial sync/backfill.
      *
@@ -123,10 +140,10 @@ export declare class ConnectorsClient {
      *             }]
      *     })
      */
-    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.
@@ -138,15 +155,15 @@ 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. 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.
      *
@@ -163,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.
@@ -179,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.
@@ -215,8 +232,45 @@ 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;
+    /**
+     * Updates per-resource settings. `acl` sets the customer-declared ACL for one connector resource (PRO-1684): the rule is normalized (emails prefixed, __public__ dominates, explicit-empty becomes __private__), persisted on the resource, and applied to enforcement immediately via the resource's ACL row, every already-indexed document of the resource is governed by it on the next query, with no re-sync. For providers with provider-derived ACL capture enabled, the provider's own ACL takes precedence again at the next sync; the rule is the standing fallback. `custom_instructions` sets the resource-level ingestion-instructions override (max 4000 characters): when set it replaces the connector-level custom_instructions for documents synced from this resource, an explicit empty string clears the override back to inheriting the connector's value, and changes apply from the next sync cycle. At least one field must be supplied; omitted fields are left unchanged.
+     *
+     * @param {HydraDB.UpdateResourceAclConnectorsRequest} request
+     * @param {ConnectorsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link HydraDB.BadRequestError}
+     * @throws {@link HydraDB.NotFoundError}
+     * @throws {@link HydraDB.InternalServerError}
+     *
+     * @example
+     *     await client.connectors.updateResourceAcl({
+     *         id: "HydraDoc1234",
+     *         resourceId: "C0123456789",
+     *         body: {
+     *             "key": "value"
+     *         }
+     *     })
+     */
+    updateResourceAcl(request: HydraDB.UpdateResourceAclConnectorsRequest, requestOptions?: ConnectorsClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
+    private __updateResourceAcl;
+    /**
+     * 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.
      *
@@ -233,6 +287,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;
 }