import { type Options as PRetryOptions } from 'p-retry';
export declare class HttpError extends Error {
    response: Response;
    statusCode: number;
    isRetryable: boolean;
    jsonBody?: unknown;
    constructor(response: Response, message?: string, options?: {
        isRetryable?: boolean;
        jsonBody?: unknown;
    });
}
export type RetryOptions = Pick<PRetryOptions, 'retries' | 'factor' | 'minTimeout' | 'onFailedAttempt'> & {
    /**
     * Maximum retry after in ms (overrides retries)
     * If retry-after header is greater than maxRetryAfter, the request will not be retried
     */
    readonly maxRetryAfter?: number;
    /**
     * Status codes to retry
     */
    readonly statusCodes?: number[];
    /**
     * Whether do retries on network errors
     */
    readonly networkErrors?: boolean;
    /**
     * Should retry will only be called for non HTTPError
     * The exception being if networkErrors is true it will not be called with network related errors
     */
    readonly shouldRetry?: (context: {
        error: Error;
        attemptNumber: number;
        retriesLeft: number;
    }) => boolean | Promise<boolean>;
};
export type URLSearchParamsInit = ConstructorParameters<typeof URLSearchParams>[0];
type RequestBaseOptions = RequestInit & {
    searchParams?: URLSearchParamsInit;
    cookieJar?: ToughCookieJar;
    json?: boolean;
    /**
     * Throw HttpError for non-2xx responses (default true)
     */
    throwOnHttpError?: boolean;
    jsonBody?: unknown;
    timeout?: number;
    retry?: RetryOptions;
};
export type RequestInitToHooks = Omit<RequestBaseOptions, 'headers' | 'searchParams' | 'jsonBody' | 'retry' | 'throwOnHttpError'> & {
    headers: Headers;
    afterResponse?: AfterResponseHook;
};
export type BeforeRequestInitToHooks = Omit<RequestBaseOptions, 'headers'> & {
    headers: Headers;
    afterResponse?: AfterResponseHook;
};
export type BeforeRequestHook = (url: URL, opts: BeforeRequestInitToHooks) => Promise<{
    url?: URL;
    opts?: BeforeRequestInitToHooks;
}>;
export type AfterResponseHook = (response: Response, url: URL, opts: RequestInitToHooks) => Promise<Response>;
export type RequestOptions = RequestBaseOptions & {
    /**
     *  Note this only occurs before the first request is made
     */
    beforeRequest?: BeforeRequestHook;
    /**
     * You can throw HttpError with isRetryable: true from this hook to retry the request
     * You may modify the url and opts here as well for the next request
     */
    afterResponse?: AfterResponseHook;
};
export type CreateOptions = RequestOptions & {
    prefixUrl?: string;
    cookieJar?: ToughCookieJar;
    json?: boolean;
};
type RequestReturn<D extends CreateOptions, T> = D extends {
    json: true;
} ? D extends {
    throwOnHttpError: false;
} | {
    throwOnHttpError?: false;
} ? Promise<T | Response> : Promise<T> : Promise<Response>;
type MergeOptions<D extends CreateOptions, O extends RequestOptions | undefined> = O extends RequestOptions ? [RequestOptions] extends [O] ? D : Omit<D, keyof O> & O : D;
type MergeExtend<D extends CreateOptions, O extends CreateOptions | undefined> = O extends CreateOptions ? Omit<D, keyof O> & O : D;
export type Request<D extends CreateOptions = CreateOptions> = {
    <T = unknown>(url: string | URL): RequestReturn<D, T>;
    <T = unknown, O extends RequestOptions & {
        json: true;
        throwOnHttpError: true;
    } = RequestOptions & {
        json: true;
        throwOnHttpError: true;
    }>(url: string | URL, options?: O): Promise<T>;
    <T = unknown, O extends RequestOptions & {
        json: true;
        throwOnHttpError: false;
    } = RequestOptions & {
        json: true;
        throwOnHttpError: false;
    }>(url: string | URL, options?: O): Promise<T | Response>;
    <T = unknown, O extends RequestOptions & {
        json: true;
        throwOnHttpError?: undefined;
    } = RequestOptions & {
        json: true;
        throwOnHttpError?: undefined;
    }>(url: string | URL, options?: O): D extends {
        throwOnHttpError: false;
    } | {
        throwOnHttpError?: false;
    } ? Promise<T | Response> : Promise<T>;
    <T = unknown, O extends RequestOptions & {
        json: true;
    } = RequestOptions & {
        json: true;
    }>(url: string | URL, options?: O): Promise<T | Response>;
    <T = unknown, O extends RequestOptions & {
        json: false;
    } = RequestOptions & {
        json: false;
    }>(url: string | URL, options?: O): Promise<Response>;
    <T = unknown, O extends RequestOptions & {
        throwOnHttpError: false;
        json?: true;
    } = RequestOptions & {
        throwOnHttpError: false;
        json?: true;
    }>(url: string | URL, options?: O): D extends {
        json: true;
    } ? Promise<T | Response> : Promise<Response>;
    <T = unknown, O extends RequestOptions = RequestOptions>(url: string | URL, options?: O): RequestReturn<MergeOptions<D, O>, T>;
    extend<T extends CreateOptions>(extendOpts: T): Request<MergeExtend<D, T>>;
};
export type ToughCookieJar = {
    getCookieString: (url: string) => Promise<string>;
    setCookie: (cookieOrString: string, currentUrl: string, options?: Record<string, unknown>) => Promise<unknown> | void;
};
declare const _default: Request<CreateOptions>;
export default _default;
//# sourceMappingURL=index.d.ts.map