import type { RequestInit, RequestInfo } from "./internal/builtin-types.js";
import type { PromiseOrValue, MergedRequestInit, FinalizedRequestInit } from "./internal/types.js";
export type { Logger, LogLevel } from "./internal/utils/log.js";
import * as Opts from "./internal/request-options.js";
import * as Errors from "./core/error.js";
import * as Pagination from "./core/pagination.js";
import { type NamespacePageParams, NamespacePageResponse } from "./core/pagination.js";
import * as Uploads from "./core/uploads.js";
import * as API from "./resources/index.js";
import * as TopLevelAPI from "./resources/top-level.js";
import { NamespaceSummariesNamespacePage, NamespaceSummary, NamespacesParams } from "./resources/top-level.js";
import { APIPromise } from "./core/api-promise.js";
import { AttributeSchema, AttributeSchemaConfig, AttributeType, Columns, DistanceMetric, FullTextSearch, FullTextSearchConfig, ID, IncludeAttributes, Language, NamespaceDeleteAllParams, NamespaceDeleteAllResponse, NamespaceExplainQueryParams, NamespaceExplainQueryResponse, NamespaceHintCacheWarmParams, NamespaceHintCacheWarmResponse, NamespaceMetadata, NamespaceMetadataParams, NamespaceMultiQueryParams, NamespaceMultiQueryResponse, NamespaceQueryParams, NamespaceQueryResponse, NamespaceRecallParams, NamespaceRecallResponse, NamespaceSchemaParams, NamespaceSchemaResponse, NamespaceUpdateSchemaParams, NamespaceUpdateSchemaResponse, NamespaceWriteParams, NamespaceWriteResponse, Namespace, Query, QueryBilling, QueryPerformance, Row, Tokenizer, Vector, VectorEncoding, WriteBilling } from "./resources/namespaces.js";
import { type Fetch } from "./internal/builtin-types.js";
import { HeadersLike, NullableHeaders } from "./internal/headers.js";
import { FinalRequestOptions, RequestOptions } from "./internal/request-options.js";
import { type LogLevel, type Logger } from "./internal/utils/log.js";
import { RequestClock } from "./internal/custom/performance.js";
export interface ClientOptions {
    /**
     * API key used for authentication
     */
    apiKey?: string | undefined;
    /**
     * The turbopuffer region to use.
     */
    region?: string | null | undefined;
    defaultNamespace?: string | null | undefined;
    /**
     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
     *
     * Defaults to process.env['TURBOPUFFER_BASE_URL'].
     */
    baseURL?: string | null | undefined;
    /**
     * The maximum amount of time (in milliseconds) that the client should wait for a response
     * from the server before timing out a single request.
     *
     * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
     * much longer than this timeout before the promise succeeds or fails.
     *
     * @unit milliseconds
     */
    timeout?: number | undefined;
    /**
     * The maximum amount of time (in milliseconds) that the client should wait for a socket
     * to be established.
     *
     * WARNING: This parameter is only supported when using the default fetch
     * implementation in Node and Deno.
     */
    connectTimeout?: number | undefined;
    /**
     * The maximum amount of time (in milliseconds) that the client should keep open a socket without
     * active connections.
     *
     * WARNING: This parameter is only supported when using the default fetch
     * implementation in Node and Deno.
     */
    idleTimeout?: number | undefined;
    /**
     * Whether to compress the request body and accept compressed responses.
     *
     * Defaults to true.
     */
    compression?: boolean | undefined;
    /**
     * Additional `RequestInit` options to be passed to `fetch` calls.
     * Properties will be overridden by per-request `fetchOptions`.
     */
    fetchOptions?: MergedRequestInit | undefined;
    /**
     * Specify a custom `fetch` function implementation.
     *
     * If not provided, we expect that `fetch` is defined globally.
     */
    fetch?: Fetch | undefined;
    /**
     * The maximum number of times that the client will retry a request in case of a
     * temporary failure, like a network error or a 5XX error from the server.
     *
     * @default 4
     */
    maxRetries?: number | undefined;
    /**
     * Default headers to include with every request to the API.
     *
     * These can be removed in individual requests by explicitly setting the
     * header to `null` in request options.
     */
    defaultHeaders?: HeadersLike | undefined;
    /**
     * Default query parameters to include with every request to the API.
     *
     * These can be removed in individual requests by explicitly setting the
     * param to `undefined` in request options.
     */
    defaultQuery?: Record<string, string | undefined> | undefined;
    /**
     * Set the log level.
     *
     * Defaults to process.env['TURBOPUFFER_LOG'] or 'warn' if it isn't set.
     */
    logLevel?: LogLevel | undefined;
    /**
     * Set the logger.
     *
     * Defaults to globalThis.console.
     */
    logger?: Logger | undefined;
}
/**
 * API Client for interfacing with the Turbopuffer API.
 */
export declare class Turbopuffer {
    #private;
    apiKey: string;
    region: string | null;
    defaultNamespace: string | null;
    readonly baseURL: string;
    maxRetries: number;
    timeout: number;
    logger: Logger | undefined;
    logLevel: LogLevel | undefined;
    fetchOptions: MergedRequestInit | undefined;
    compression: boolean;
    private fetch;
    protected idempotencyHeader?: string;
    private _options;
    /**
     * API Client for interfacing with the Turbopuffer API.
     *
     * @param {string | undefined} [opts.apiKey=process.env['TURBOPUFFER_API_KEY'] ?? undefined]
     * @param {string | null | undefined} [opts.region=process.env['TURBOPUFFER_REGION'] ?? null]
     * @param {string | null | undefined} [opts.defaultNamespace]
     * @param {string} [opts.baseURL=process.env['TURBOPUFFER_BASE_URL'] ?? https://{region}.turbopuffer.com] - Override the default base URL for the API.
     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
     * @param {number} [opts.maxRetries=4] - The maximum number of times the client will retry a request.
     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
     */
    constructor({ baseURL, apiKey, region, defaultNamespace, ...opts }?: ClientOptions);
    /**
     * Create a new client instance re-using the same options given to the current client with optional overriding.
     */
    withOptions(options: Partial<ClientOptions>): this;
    /**
     * Construct a namespace resource.
     */
    namespace(namespace: string): API.Namespace;
    /**
     * List namespaces.
     */
    namespaces(query?: TopLevelAPI.NamespacesParams | null | undefined, options?: RequestOptions): Pagination.PagePromise<NamespaceSummariesNamespacePage, TopLevelAPI.NamespaceSummary>;
    protected defaultQuery(): Record<string, string | undefined> | undefined;
    protected validateHeaders({ values, nulls }: NullableHeaders): void;
    protected authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    /**
     * Basic re-implementation of `qs.stringify` for primitive types.
     */
    protected stringifyQuery(query: Record<string, unknown>): string;
    private getUserAgent;
    protected defaultIdempotencyKey(): string;
    protected makeStatusError(status: number, error: Object, message: string | undefined, headers: Headers): Errors.APIError;
    buildURL(path: string, query: Record<string, unknown> | null | undefined, defaultBaseURL?: string | undefined): string;
    /**
     * Used as a callback for mutating the given `FinalRequestOptions` object.
     */
    protected prepareOptions(options: FinalRequestOptions): Promise<void>;
    /**
     * Used as a callback for mutating the given `RequestInit` object.
     *
     * This is useful for cases where you want to add certain headers based off of
     * the request properties, e.g. `method` or `url`.
     */
    protected prepareRequest(request: RequestInit, { url, options }: {
        url: string;
        options: FinalRequestOptions;
    }): Promise<void>;
    get<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    post<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    patch<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    put<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    delete<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    private methodRequest;
    request<Rsp>(options: PromiseOrValue<FinalRequestOptions>, remainingRetries?: number | null): APIPromise<Rsp>;
    private makeRequest;
    getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(path: string, Page: new (...args: any[]) => PageClass, opts?: RequestOptions): Pagination.PagePromise<PageClass, Item>;
    requestAPIList<Item = unknown, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass, options: FinalRequestOptions): Pagination.PagePromise<PageClass, Item>;
    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
    private shouldRetry;
    private retryRequest;
    private calculateDefaultRetryTimeoutMillis;
    buildRequest(inputOptions: FinalRequestOptions, { retryCount, clock }?: {
        retryCount?: number;
        clock: RequestClock;
    }): Promise<{
        req: FinalizedRequestInit;
        url: string;
        timeout: number;
    }>;
    private buildHeaders;
    private buildBody;
    static Turbopuffer: typeof Turbopuffer;
    static DEFAULT_TIMEOUT: number;
    static TurbopufferError: typeof Errors.TurbopufferError;
    static APIError: typeof Errors.APIError;
    static APIConnectionError: typeof Errors.APIConnectionError;
    static APIConnectionTimeoutError: typeof Errors.APIConnectionTimeoutError;
    static APIUserAbortError: typeof Errors.APIUserAbortError;
    static NotFoundError: typeof Errors.NotFoundError;
    static ConflictError: typeof Errors.ConflictError;
    static RateLimitError: typeof Errors.RateLimitError;
    static BadRequestError: typeof Errors.BadRequestError;
    static AuthenticationError: typeof Errors.AuthenticationError;
    static InternalServerError: typeof Errors.InternalServerError;
    static PermissionDeniedError: typeof Errors.PermissionDeniedError;
    static UnprocessableEntityError: typeof Errors.UnprocessableEntityError;
    static toFile: typeof Uploads.toFile;
}
export declare namespace Turbopuffer {
    export type RequestOptions = Opts.RequestOptions;
    export import NamespacePage = Pagination.NamespacePage;
    export { type NamespacePageParams as NamespacePageParams, type NamespacePageResponse as NamespacePageResponse, };
    export { type NamespaceSummary as NamespaceSummary, type NamespaceSummariesNamespacePage as NamespaceSummariesNamespacePage, type NamespacesParams as NamespacesParams, };
    export { Namespace as Namespace, type AttributeSchema as AttributeSchema, type AttributeSchemaConfig as AttributeSchemaConfig, type AttributeType as AttributeType, type Columns as Columns, type DistanceMetric as DistanceMetric, type FullTextSearch as FullTextSearch, type FullTextSearchConfig as FullTextSearchConfig, type ID as ID, type IncludeAttributes as IncludeAttributes, type Language as Language, type NamespaceMetadata as NamespaceMetadata, type Query as Query, type QueryBilling as QueryBilling, type QueryPerformance as QueryPerformance, type Row as Row, type Tokenizer as Tokenizer, type Vector as Vector, type VectorEncoding as VectorEncoding, type WriteBilling as WriteBilling, type NamespaceDeleteAllResponse as NamespaceDeleteAllResponse, type NamespaceExplainQueryResponse as NamespaceExplainQueryResponse, type NamespaceHintCacheWarmResponse as NamespaceHintCacheWarmResponse, type NamespaceMultiQueryResponse as NamespaceMultiQueryResponse, type NamespaceQueryResponse as NamespaceQueryResponse, type NamespaceRecallResponse as NamespaceRecallResponse, type NamespaceSchemaResponse as NamespaceSchemaResponse, type NamespaceUpdateSchemaResponse as NamespaceUpdateSchemaResponse, type NamespaceWriteResponse as NamespaceWriteResponse, type NamespaceDeleteAllParams as NamespaceDeleteAllParams, type NamespaceExplainQueryParams as NamespaceExplainQueryParams, type NamespaceHintCacheWarmParams as NamespaceHintCacheWarmParams, type NamespaceMetadataParams as NamespaceMetadataParams, type NamespaceMultiQueryParams as NamespaceMultiQueryParams, type NamespaceQueryParams as NamespaceQueryParams, type NamespaceRecallParams as NamespaceRecallParams, type NamespaceSchemaParams as NamespaceSchemaParams, type NamespaceUpdateSchemaParams as NamespaceUpdateSchemaParams, type NamespaceWriteParams as NamespaceWriteParams, };
}
//# sourceMappingURL=client.d.ts.map