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";
import * as core from "./core/index.js";
export declare namespace HydraDBClient {
    type Options = BaseClientOptions;
    interface RequestOptions extends BaseRequestOptions {
    }
}
export declare class HydraDBClient {
    protected readonly _options: NormalizedClientOptionsWithAuth<HydraDBClient.Options>;
    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.
     *
     * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @example
     *     await client.catalog()
     */
    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).
     *
     * @param {HydraDB.ListProvidersRequest} request
     * @param {HydraDBClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link HydraDB.NotFoundError}
     *
     * @example
     *     await client.listProviders({
     *         id: "HydraDoc1234"
     *     })
     */
    listProviders(request?: HydraDB.ListProvidersRequest, requestOptions?: HydraDBClient.RequestOptions): core.HttpResponsePromise<HydraDB.HandlerProviderListResponse>;
    private __listProviders;
    /**
     * Unified query endpoint that dispatches across type and query_by (hybrid/text). Optionally filter by one or more exact document titles with `titles`; these are resolved to source IDs before normal retrieval. Filter with `attributes` (an operator language, pushed into the vector search); `metadata_filters` is deprecated in favour of it and still works. On a SPLIT database `type` is knowledge (the default), memory, or all (both, merged), unchanged. On a UNIFIED database there is one corpus: omit `type`, or send `unified` (`all` is accepted and means the same); knowledge and memory are rejected there. 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.NotFoundError}
     * @throws {@link HydraDB.InternalServerError}
     *
     * @example
     *     await client.query()
     */
    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.
     * This is useful for making requests to endpoints not yet supported in the SDK.
     * The input can be a URL string, URL object, or Request object. Relative paths are resolved against the configured base URL.
     *
     * @param {Request | string | URL} input - The URL, path, or Request object.
     * @param {RequestInit} init - Standard fetch RequestInit options.
     * @param {core.PassthroughRequest.RequestOptions} requestOptions - Per-request overrides (timeout, retries, headers, abort signal).
     * @returns {Promise<Response>} A standard Response object.
     */
    fetch(input: Request | string | URL, init?: RequestInit, requestOptions?: core.PassthroughRequest.RequestOptions): Promise<Response>;
}