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 Uploads from "./core/uploads.js";
import * as API from "./resources/index.js";
import { APIPromise } from "./core/api-promise.js";
import { FixParsingAndDiagnose, FixParsingAndDiagnoseDetectIssuesParams, FixParsingAndDiagnoseDetectIssuesResponse } from "./resources/fix-parsing-and-diagnose.js";
import { FixStringLiteralCreateParams, FixStringLiteralCreateResponse, FixStringLiterals } from "./resources/fix-string-literals.js";
import { Fixer, FixerRunParams, FixerRunResponse } from "./resources/fixer.js";
import * as FixerAPI from "./resources/fixer.js";
import { StackBundleMultipartParams, StackBundleMultipartResponse, StackCreateAndRunParams, StackCreateAndRunResponse, StackCreateParams, StackCreateResponse, StackExecuteCommandParams, StackExecuteCommandResponse, StackGetLogsParams, StackGetLogsResponse, StackGetNetworkInfoResponse, StackReadFileParams, StackReadFileResponse, StackResetParams, StackResetResponse, StackRetrieveResponse, StackUpdateParams, StackUpdateResponse, StackWaitForDevServerURLParams, StackWaitForDevServerURLResponse, StackWriteFileParams, StackWriteFileResponse, Stacks as StacksAPI } from "./resources/stacks/stacks.js";
import { ValidateTemplate, ValidateTemplateValidateParams, ValidateTemplateValidateResponse } from "./resources/validate-template.js";
import { Stacks } from "./stacks.js";
import { Fix, FixCreateAIFallbackParams, FixCreateAIFallbackResponse } from "./resources/fix/fix.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";
export interface ClientOptions {
    /**
     * Defaults to process.env['BENCHIFY_API_KEY'].
     */
    apiKey?: string | null | undefined;
    /**
     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
     *
     * Defaults to process.env['BENCHIFY_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;
    /**
     * 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 2
     */
    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['BENCHIFY_LOG'] or 'warn' if it isn't set.
     */
    logLevel?: LogLevel | undefined;
    /**
     * Set the logger.
     *
     * Defaults to globalThis.console.
     */
    logger?: Logger | undefined;
}
type ResponseFormat = 'DIFF' | 'CHANGED_FILES' | 'ALL_FILES';
type FixerOutput<T extends ResponseFormat> = T extends 'ALL_FILES' ? Array<FixerAPI.File> : T extends 'CHANGED_FILES' ? Array<FixerAPI.File> : T extends 'DIFF' ? string : never;
type FixerBundleOutput<T extends ResponseFormat> = {
    files: FixerOutput<T>;
    bundled_files: Array<FixerAPI.File>;
    initial_diagnostics?: FixerAPI.FixerRunResponse.Data.PartitionedDiagnosticResponse | null;
    final_diagnostics?: FixerAPI.FixerRunResponse.Data.PartitionedDiagnosticResponse | null;
};
type FixerOutputWithDiagnostics<T extends ResponseFormat> = {
    files: FixerOutput<T>;
    initial_diagnostics?: FixerAPI.FixerRunResponse.Data.PartitionedDiagnosticResponse | null;
    final_diagnostics?: FixerAPI.FixerRunResponse.Data.PartitionedDiagnosticResponse | null;
};
/**
 * API Client for interfacing with the Benchify API.
 */
export declare class Benchify {
    #private;
    apiKey: string | null;
    baseURL: string;
    maxRetries: number;
    timeout: number;
    logger: Logger | undefined;
    logLevel: LogLevel | undefined;
    fetchOptions: MergedRequestInit | undefined;
    private fetch;
    protected idempotencyHeader?: string;
    private _options;
    /**
     * API Client for interfacing with the Benchify API.
     *
     * @param {string | null | undefined} [opts.apiKey=process.env['BENCHIFY_API_KEY'] ?? null]
     * @param {string} [opts.baseURL=process.env['BENCHIFY_BASE_URL'] ?? https://api.benchify.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=2] - 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, ...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;
    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;
    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
    private shouldRetry;
    private retryRequest;
    private calculateDefaultRetryTimeoutMillis;
    buildRequest(inputOptions: FinalRequestOptions, { retryCount }?: {
        retryCount?: number;
    }): Promise<{
        req: FinalizedRequestInit;
        url: string;
        timeout: number;
    }>;
    private buildHeaders;
    private buildBody;
    static Benchify: typeof Benchify;
    static DEFAULT_TIMEOUT: number;
    static BenchifyError: typeof Errors.BenchifyError;
    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;
    fixer: API.Fixer;
    /**
     * Process all files using the fixer with a simplified interface.
     * Uses multipart form with tar.zst compression for efficient transfer.
     *
     * @param files - Array of files to process
     * @param options - Optional parameters for the fixer run
     * @returns Promise resolving to the appropriate format based on response_format and bundle flag
     *
     * @example
     * ```ts
     * // Get all files (default)
     * const result = await client.runFixer([
     *   { path: "src/index.ts", contents: "export const hello = 'world';" },
     *   { path: "src/utils.ts", contents: "export function helper() {}" }
     * ]);
     * console.log('Fixed files:', result.files);
     *
     * // Get only changed files
     * const changedResult = await client.runFixer([
     *   { path: "src/index.ts", contents: "export const hello = 'world';" }
     * ], { response_format: 'CHANGED_FILES' });
     * console.log('Changed files:', changedResult.files);
     *
     * // Get diff format
     * const diffResult = await client.runFixer([
     *   { path: "src/index.ts", contents: "export const hello = 'world';" }
     * ], { response_format: 'DIFF' });
     * console.log('Diff:', diffResult.files);
     *
     * // Get bundled files alongside regular files
     * const bundleResult = await client.runFixer([
     *   { path: "src/index.ts", contents: "export const hello = 'world';" }
     * ], { response_format: 'ALL_FILES', bundle: true });
     * console.log('Files:', bundleResult.files);
     * console.log('Bundled files:', bundleResult.bundled_files);
     * ```
     */
    runFixer<T extends ResponseFormat = 'ALL_FILES', B extends boolean = false>(files: API.FixerRunParams.File[], options?: Partial<API.FixerRunParams> & {
        response_format?: T;
        bundle?: B;
    }): Promise<B extends true ? FixerBundleOutput<T> : FixerOutputWithDiagnostics<T>>;
    stacks: API.Stacks;
    fixStringLiterals: API.FixStringLiterals;
    validateTemplate: API.ValidateTemplate;
    stack: Stacks;
    fixParsingAndDiagnose: API.FixParsingAndDiagnose;
    fix: API.Fix;
}
export declare namespace Benchify {
    export type RequestOptions = Opts.RequestOptions;
    export { Fixer as Fixer, type FixerRunResponse as FixerRunResponse, type FixerRunParams as FixerRunParams };
    export { StacksAPI as Stacks, type StackCreateResponse as StackCreateResponse, type StackRetrieveResponse as StackRetrieveResponse, type StackUpdateResponse as StackUpdateResponse, type StackBundleMultipartResponse as StackBundleMultipartResponse, type StackCreateAndRunResponse as StackCreateAndRunResponse, type StackExecuteCommandResponse as StackExecuteCommandResponse, type StackGetLogsResponse as StackGetLogsResponse, type StackGetNetworkInfoResponse as StackGetNetworkInfoResponse, type StackReadFileResponse as StackReadFileResponse, type StackResetResponse as StackResetResponse, type StackWaitForDevServerURLResponse as StackWaitForDevServerURLResponse, type StackWriteFileResponse as StackWriteFileResponse, type StackCreateParams as StackCreateParams, type StackUpdateParams as StackUpdateParams, type StackBundleMultipartParams as StackBundleMultipartParams, type StackCreateAndRunParams as StackCreateAndRunParams, type StackExecuteCommandParams as StackExecuteCommandParams, type StackGetLogsParams as StackGetLogsParams, type StackReadFileParams as StackReadFileParams, type StackResetParams as StackResetParams, type StackWaitForDevServerURLParams as StackWaitForDevServerURLParams, type StackWriteFileParams as StackWriteFileParams, };
    export { FixStringLiterals as FixStringLiterals, type FixStringLiteralCreateResponse as FixStringLiteralCreateResponse, type FixStringLiteralCreateParams as FixStringLiteralCreateParams, };
    export { ValidateTemplate as ValidateTemplate, type ValidateTemplateValidateResponse as ValidateTemplateValidateResponse, type ValidateTemplateValidateParams as ValidateTemplateValidateParams, };
    export { FixParsingAndDiagnose as FixParsingAndDiagnose, type FixParsingAndDiagnoseDetectIssuesResponse as FixParsingAndDiagnoseDetectIssuesResponse, type FixParsingAndDiagnoseDetectIssuesParams as FixParsingAndDiagnoseDetectIssuesParams, };
    export { Fix as Fix, type FixCreateAIFallbackResponse as FixCreateAIFallbackResponse, type FixCreateAIFallbackParams as FixCreateAIFallbackParams, };
}
export interface Benchify {
    stacks: API.Stacks;
    fixer: API.Fixer;
    fixStringLiterals: API.FixStringLiterals;
    validateTemplate: API.ValidateTemplate;
    stack: Stacks;
}
//# sourceMappingURL=client.d.ts.map