/**
 * Global default options as {@link Options} that are applied to **all** mande
 * instances. Always contain an initialized `headers` property with the default
 * headers:
 * - Accept: 'application/json'
 * - 'Content-Type': 'application/json'
 */
export declare const defaults: _OptionsDefaults;

declare type InferArgs<F> = F extends (api: MandeInstance, ...args: infer A) => any ? A : never;

/**
 * Create a Mande instance
 *
 * @example
 * ```js
 * const users = mande('/api/users')
 * users.get('2').then(user => {
 *   // do something
 * })
 * ```
 * @param baseURL - absolute url
 * @param passedInstanceOptions - optional options that will be applied to every
 * other request for this instance
 */
export declare function mande(baseURL: string, passedInstanceOptions?: OptionsRaw, fetchPolyfill?: Window['fetch']): MandeInstance;

/**
 * Extended Error with the raw `Response` object.
 */
export declare interface MandeError<T = any> extends Error {
    body: T;
    response: Response;
}

/**
 * Object returned by {@link mande}
 */
export declare interface MandeInstance {
    /**
     * Writable options.
     */
    options: Required<Pick<OptionsRaw, 'headers'>> & Omit<OptionsRaw, 'headers'>;
    /**
     * Sends a GET request to the base url. This is equivalent to calling get with an empty string.
     *
     * @example
     * ```js
     * const userList = await users.get()
     * ```
     * @param options - optional {@link Options}
     */
    get<T = unknown, R extends ResponseAsTypes = 'json'>(options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a GET request to the given url.
     *
     * @example
     * ```js
     * const userProfile = await users.get('2')
     * ```
     * @param url - optional relative url to send the request to
     * @param options - optional {@link Options}
     */
    get<T = unknown, R extends ResponseAsTypes = 'json'>(url: string | number, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a POST request to the base url. This is equivalent to calling post with an empty string.
     *
     * @example
     * ```js
     * const createdUser = await users.post({ name: 'Eduardo' })
     * ```
     * @param data - optional body of the request
     * @param options - optional {@link Options}
     */
    post<T = unknown, R extends ResponseAsTypes = 'json'>(data?: any, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a POST request to the given url.
     *
     * @example
     * ```js
     * const createdUser = await users.post('', { name: 'Eduardo' })
     * ```
     * @param url - relative url to send the request to
     * @param data - optional body of the request
     * @param options - optional {@link Options}
     */
    post<T = unknown, R extends ResponseAsTypes = 'json'>(url: string | number, data?: any, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a PUT request to the base url. This is equivalent to calling put with an empty string.
     *
     * @example
     * ```js
     * users.put({ name: 'Eduardo' })
     * ```
     * @param data - optional body of the request
     * @param options - optional {@link Options}
     */
    put<T = unknown, R extends ResponseAsTypes = 'json'>(data?: any, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a PUT request to the given url.
     *
     * @example
     * ```js
     * users.put('2', { name: 'Eduardo' })
     * ```
     * @param url - relative url to send the request to
     * @param data - optional body of the request
     * @param options - optional {@link Options}
     */
    put<T = unknown, R extends ResponseAsTypes = 'json'>(url: string | number, data?: any, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a PATCH request to the base url. This is equivalent to calling patch with an empty string.
     *
     * @example
     * ```js
     * users.patch({ name: 'Eduardo' })
     * ```
     * @param data - optional body of the request
     * @param options - optional {@link Options}
     */
    patch<T = unknown, R extends ResponseAsTypes = 'json'>(data?: any, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a PATCH request to the given url.
     *
     * @example
     * ```js
     * users.patch('2', { name: 'Eduardo' })
     * ```
     */
    patch<T = unknown, R extends ResponseAsTypes = 'json'>(url: string | number, data?: any, options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a DELETE request to the base url. This is equivalent to calling delete with an empty string.
     *
     * @example
     * ```js
     * users.delete()
     * ```
     * @param options - optional {@link Options}
     */
    delete<T = unknown, R extends ResponseAsTypes = 'json'>(options?: Options<R>): MandeResponse<T, R>;
    /**
     * Sends a DELETE request to the given url.
     *
     * @example
     * ```js
     * users.delete('2')
     * ```
     * @param url - relative url to send the request to
     * @param options - optional {@link Options}
     */
    delete<T = unknown, R extends ResponseAsTypes = 'json'>(url: string | number, options?: Options<R>): MandeResponse<T, R>;
}

export declare type MandeResponse<T = unknown, ResponseType extends ResponseAsTypes = 'json'> = Promise<ResponseType extends 'response' ? Response : ResponseType extends 'text' ? string : T>;

/**
 * Creates an Nuxt 2 SSR compatible function that automatically proxies cookies to requests and works transparently on
 * the server and client (it still requires a fetch polyfill on Node). Note this is only needed if you need to proxy
 * cookies to the server.
 *
 * @example
 * ```js
 * import { mande, nuxtWrap } from 'mande'
 *
 * const fetchPolyfill = process.server ? require('node-fetch') : fetch
 * const users = mande(BASE_URL + '/api/users', {}, fetchPolyfill)
 *
 * export const getUserById = nuxtWrap(users, (api, id: string) => api.get(id))
 * ```
 *
 * @param api - Mande instance to wrap
 * @param fn - function to be wrapped
 */
export declare function nuxtWrap<M extends MandeInstance, F extends (api: M, ...args: any[]) => any>(api: M, fn: F): (...args: InferArgs<F>) => ReturnType<F>;

/**
 * Allowed options for a request. Extends native `RequestInit`.
 */
export declare interface Options<ResponseAs extends ResponseAsTypes = ResponseAsTypes> extends RequestInit {
    /**
     * Optional query object. Does not support arrays. Will get stringified
     */
    query?: any;
    /**
     * What kind of response is expected. Defaults to `json`. `response` will
     * return the raw response from `fetch`.
     */
    responseAs?: ResponseAs;
    /**
     * Headers sent alongside the request
     */
    headers?: Record<string, string>;
    /**
     * Optional function to stringify the body of the request for POST and PUT requests. Defaults to `JSON.stringify`.
     */
    stringify?: (data: unknown) => string;
}

/**
 * Used internally for merged options.
 * @internal
 */
export declare type _OptionsDefaults = Options & Pick<Required<Options>, 'headers' | 'responseAs' | 'stringify'>;

/**
 * Used internally for merged options
 *
 * @internal
 */
export declare type _OptionsMerged = _OptionsDefaults & Pick<Required<Options>, 'method'>;

export declare interface OptionsRaw<R extends ResponseAsTypes = ResponseAsTypes> extends Omit<Options<R>, 'headers' | 'signal'> {
    /**
     * Headers sent alongside the request. Set any header to null to remove it.
     */
    headers?: Record<string, string | null>;
    /**
     * AbortSignal can only be passed to requests, not to a mande instance
     * because it can only be used once.
     */
    signal?: never;
}

export declare type ResponseAsTypes = 'json' | 'text' | 'response';

export { }