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 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>;
export type OpenAPIClientAxiosOptions = {
    definition: Document | string;
    quick?: boolean;
    withServer?: number | string | Server;
    baseURLVariables?: {
        [key: string]: string | number;
    };
    applyMethodCommonHeaders?: boolean;
    transformOperationName?: (operation: string) => string;
    transformOperationMethod?: (operationMethod: UnknownOperationMethod, operationToTransform: Operation) => UnknownOperationMethod;
    axiosRunner?: (axiosConfig: AxiosRequestConfig) => Promise<AxiosResponse>;
    axiosConfigDefaults?: AxiosRequestConfig;
} & ({
    axiosConfigDefaults?: AxiosRequestConfig;
    axiosInstance?: never;
} | {
    axiosConfigDefaults?: never;
    axiosInstance?: AxiosInstance;
});
/**
 * 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
     * @param {boolean} opts.axiosInstance - axios instance to use
     * @memberof OpenAPIClientAxios
     */
    constructor(opts: OpenAPIClientAxiosOptions);
    /**
     * 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, if necessary, 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) => AxiosRequestConfig;
    /**
     * 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;
}