import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import { Document, Operation, UnknownOperationMethod, OperationMethodArguments, UnknownOperationMethods, RequestConfig, UnknownPathsDictionary, Server } from './types/client';
/**
 * OpenAPIClient is an AxiosInstance extended with operation methods
 */
export declare type OpenAPIClient<OperationMethods = UnknownOperationMethods, PathsDictionary = UnknownPathsDictionary> = AxiosInstance & OperationMethods & {
    api: OpenAPIClientAxios;
    paths: PathsDictionary;
};
/**
 * By default OpenAPIClient will use axios as request runner. You can register a different runner,
 * in case you want to switch over from axios.
 */
export declare type Runner = {
    runRequest: RunRequestFunc;
    context?: UnknownContext;
};
/**
 * Context to be injected into Runner.runRequest
 */
export declare type UnknownContext = Record<string, unknown>;
/**
 * Type for runRequest function. It allows extending/switching from axios to another method of running http requests.
 */
export declare type RunRequestFunc = (axiosConfig: AxiosRequestConfig, operation: Operation, context?: UnknownContext) => Promise<AxiosResponse>;
/**
 * Main class and the default export of the 'openapi-client-axios' module
 *
 * @export
 * @class OpenAPIClientAxios
 */
export declare class OpenAPIClientAxios {
    document: Document;
    inputDocument: Document | string;
    definition: Document;
    quick: boolean;
    initialized: boolean;
    instance: any;
    axiosConfigDefaults: AxiosRequestConfig;
    private defaultServer;
    private baseURLVariables;
    private applyMethodCommonHeaders;
    private transformOperationName;
    private transformOperationMethod;
    private runners;
    /**
     * Creates an instance of OpenAPIClientAxios.
     *
     * @param opts - constructor options
     * @param {Document | string} opts.definition - the OpenAPI definition, file path or Document object
     * @param {boolean} opts.quick - quick mode, skips validation and doesn't guarantee document is unchanged
     * @param {boolean} opts.applyMethodCommonHeaders Should method (patch / post / put / etc.) specific default headers (from axios.defaults.headers.{method}) be applied to operation methods?
     * @param {boolean} opts.axiosConfigDefaults - default axios config for the instance
     * @memberof OpenAPIClientAxios
     */
    constructor(opts: {
        definition: Document | string;
        quick?: boolean;
        axiosConfigDefaults?: AxiosRequestConfig;
        withServer?: number | string | Server;
        baseURLVariables?: {
            [key: string]: string | number;
        };
        applyMethodCommonHeaders?: boolean;
        transformOperationName?: (operation: string) => string;
        transformOperationMethod?: (operationMethod: UnknownOperationMethod, operationToTransform: Operation) => UnknownOperationMethod;
    });
    /**
     * Returns the instance of OpenAPIClient
     *
     * @readonly
     * @type {OpenAPIClient}
     * @memberof OpenAPIClientAxios
     */
    get client(): OpenAPIClient<UnknownOperationMethods, UnknownPathsDictionary>;
    /**
     * Returns the instance of OpenAPIClient
     *
     * @returns
     * @memberof OpenAPIClientAxios
     */
    getClient: <Client = OpenAPIClient<UnknownOperationMethods, UnknownPathsDictionary>>() => Promise<Client>;
    withServer(server: number | string | Server, variables?: {
        [key: string]: string | number;
    }): void;
    /**
     * Initializes OpenAPIClientAxios and creates a member axios client instance
     *
     * The init() method should be called right after creating a new instance of OpenAPIClientAxios
     *
     * @returns AxiosInstance
     * @memberof OpenAPIClientAxios
     */
    init: <Client = OpenAPIClient<UnknownOperationMethods, UnknownPathsDictionary>>() => Promise<Client>;
    /**
     * Loads document from inputDocument
     *
     * Supports loading from a string (url) or an object (json)
     *
     * @memberof OpenAPIClientAxios
     */
    loadDocument(): Promise<Document>;
    /**
     * Synchronous version of .init()
     *
     * Note: Only works when the input definition is a valid OpenAPI v3 object (URLs are not supported)
     *
     * @memberof OpenAPIClientAxios
     */
    initSync: <Client = OpenAPIClient<UnknownOperationMethods, UnknownPathsDictionary>>() => Client;
    /**
     * Creates a new axios instance with defaults and returns it
     */
    getAxiosInstance: () => AxiosInstance;
    /**
     * Creates a new axios instance, extends it and returns it
     *
     * @memberof OpenAPIClientAxios
     */
    createAxiosInstance: <Client = OpenAPIClient<UnknownOperationMethods, UnknownPathsDictionary>>() => Client;
    /**
     * Gets the API baseurl defined in the first OpenAPI specification servers property
     *
     * @returns string
     * @memberof OpenAPIClientAxios
     */
    getBaseURL: (operation?: Operation) => string | undefined;
    /**
     * Creates an axios config object for operation + arguments
     * @memberof OpenAPIClientAxios
     */
    getAxiosConfigForOperation: (operation: Operation | string, args: OperationMethodArguments) => {
        headers: {
            [x: string]: string | number | boolean | string[] | import("axios").AxiosHeaders;
            link?: import("axios").AxiosHeaders;
            head?: import("axios").AxiosHeaders;
            options?: import("axios").AxiosHeaders;
            get?: import("axios").AxiosHeaders;
            delete?: import("axios").AxiosHeaders;
            post?: import("axios").AxiosHeaders;
            put?: import("axios").AxiosHeaders;
            patch?: import("axios").AxiosHeaders;
            purge?: import("axios").AxiosHeaders;
            unlink?: import("axios").AxiosHeaders;
            common?: import("axios").AxiosHeaders;
        };
        url?: string;
        method?: string;
        baseURL?: string;
        transformRequest?: import("axios").AxiosRequestTransformer | import("axios").AxiosRequestTransformer[];
        transformResponse?: import("axios").AxiosResponseTransformer | import("axios").AxiosResponseTransformer[];
        params?: any;
        paramsSerializer?: import("axios").ParamsSerializerOptions;
        data?: any;
        timeout?: number;
        timeoutErrorMessage?: string;
        withCredentials?: boolean;
        adapter?: import("axios").AxiosAdapter;
        auth?: import("axios").AxiosBasicCredentials;
        responseType?: import("axios").ResponseType;
        responseEncoding?: string;
        xsrfCookieName?: string;
        xsrfHeaderName?: string;
        onUploadProgress?: (progressEvent: import("axios").AxiosProgressEvent) => void;
        onDownloadProgress?: (progressEvent: import("axios").AxiosProgressEvent) => void;
        maxContentLength?: number;
        validateStatus?: (status: number) => boolean;
        maxBodyLength?: number;
        maxRedirects?: number;
        maxRate?: number | [number, number];
        beforeRedirect?: (options: Record<string, any>, responseDetails: {
            headers: Record<string, string>;
        }) => void;
        socketPath?: string;
        httpAgent?: any;
        httpsAgent?: any;
        proxy?: false | import("axios").AxiosProxyConfig;
        cancelToken?: import("axios").CancelToken;
        decompress?: boolean;
        transitional?: import("axios").TransitionalOptions;
        signal?: import("axios").GenericAbortSignal;
        insecureHTTPParser?: boolean;
        env?: {
            FormData?: new (...args: any[]) => object;
        };
        formSerializer?: import("axios").FormSerializerOptions;
    };
    /**
     * Creates a generic request config object for operation + arguments.
     *
     * This function contains the logic that handles operation method parameters.
     *
     * @memberof OpenAPIClientAxios
     */
    getRequestConfigForOperation: (operation: Operation | string, args: OperationMethodArguments) => RequestConfig;
    /**
     * Flattens operations into a simple array of Operation objects easy to work with
     *
     * @returns {Operation[]}
     * @memberof OpenAPIBackend
     */
    getOperations: () => Operation[];
    /**
     * Gets a single operation based on operationId
     *
     * @param {string} operationId
     * @returns {Operation}
     * @memberof OpenAPIBackend
     */
    getOperation: (operationId: string) => Operation | undefined;
    /**
     * By default OpenAPIClient will use axios as request runner. You can register a different runner,
     * in case you want to switch over from axios. This allows transitioning from axios to your library of choice.
     * @param runner - request runner to be registered, either for all operations, or just one operation.
     * @param operationId - optional parameter. If provided, runner will be registered for a single operation. Else, it will be registered for all operations.
     */
    registerRunner(runner: Runner, operationId?: string): void;
    private getRunner;
    /**
     * Creates an axios method for an operation
     * (...pathParams, data?, config?) => Promise<AxiosResponse>
     *
     * @param {Operation} operation
     * @memberof OpenAPIClientAxios
     */
    private createOperationMethod;
}