import { AxiosRequestConfig, AxiosResponse, AxiosInstance } from "axios";
export interface RequestConfig extends AxiosRequestConfig {
    extraMap?: Record<string, any>;
}
export interface Response<T = any> extends AxiosResponse<T> {
}
export type LogCallback = (config: RequestConfig, response: Response) => void;
export declare const nonHTTPRequestMethod: (target: any, methodName: string) => void;
export declare class BaseService {
    __meta__: any;
    private _endpoint;
    private _httpClient;
    private _methodMap;
    private _timeout;
    private _logCallback;
    constructor(serviceBuilder: ServiceBuilder);
    isClientStandalone(): boolean;
    useRequestInterceptor(interceptor: RequestInterceptorFunction): number;
    useResponseInterceptor(interceptor: ResponseInterceptorFunction): number;
    ejectRequestInterceptor(id: number): void;
    ejectResponseInterceptor(id: number): void;
    setEndpoint(endpoint: string): void;
    setLogCallback(logCallback: LogCallback | null): void;
    setTimeout(timeout: number): void;
    private _getInstanceMethodNames;
    private _wrap;
    private _resolveParameters;
    private _makeConfig;
    private _resolveUrl;
    private makeURL;
    private _resolveHttpMethod;
    private _resolveHeaders;
    private _resolveQuery;
    private _resolveSignal;
    private _resolveExtraMap;
    private _resolveOnUploadProgress;
    private _resolveData;
}
export type RequestInterceptorFunction = (value: AxiosRequestConfig) => AxiosRequestConfig | Promise<AxiosRequestConfig>;
export type ResponseInterceptorFunction<T = any> = (value: AxiosResponse<T>) => AxiosResponse<T> | Promise<AxiosResponse<T>>;
declare abstract class BaseInterceptor {
    onRejected(error: any): void;
}
export declare abstract class RequestInterceptor extends BaseInterceptor {
    abstract onFulfilled(value: AxiosRequestConfig): AxiosRequestConfig | Promise<AxiosRequestConfig>;
}
export declare abstract class ResponseInterceptor<T = any> extends BaseInterceptor {
    abstract onFulfilled(value: AxiosResponse<T>): AxiosResponse<T> | Promise<AxiosResponse<T>>;
}
export declare class ServiceBuilder {
    private _endpoint;
    private _standalone;
    private _requestInterceptors;
    private _responseInterceptors;
    private _timeout;
    private _logCallback;
    build<T>(service: new (builder: ServiceBuilder) => T): T;
    setEndpoint(endpoint: string): ServiceBuilder;
    setStandalone(standalone: boolean | AxiosInstance): ServiceBuilder;
    setRequestInterceptors(...interceptors: Array<RequestInterceptorFunction | RequestInterceptor>): ServiceBuilder;
    setResponseInterceptors(...interceptors: Array<ResponseInterceptorFunction | ResponseInterceptor>): ServiceBuilder;
    setTimeout(timeout: number): ServiceBuilder;
    setLogCallback(logCallback: LogCallback): ServiceBuilder;
    get endpoint(): string;
    get standalone(): boolean | AxiosInstance;
    get requestInterceptors(): Array<RequestInterceptorFunction | RequestInterceptor>;
    get responseInterceptors(): Array<ResponseInterceptorFunction | ResponseInterceptor>;
    get timeout(): number;
    get logCallback(): LogCallback | null;
}
export {};