import EventEmitter$1 from 'events';

type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
type EmptyTypes = null | undefined;
type NullableType<T> = T | EmptyTypes;
type NullableKeys<T> = {
    [P in keyof T]-?: NullableType<T[P]>;
};
type NonNullableKeys<T> = {
    [P in keyof T]-?: NonNullable<T[P]>;
};
type RequiredKeys<T> = {
    [P in keyof T]-?: Exclude<T[P], EmptyTypes>;
};
type TypeWithDefaults<Types extends Record<string, any>, Key extends keyof Types, Value, ExcludedTypes = void | never> = Key extends keyof Types ? Exclude<Types[Key], ExcludedTypes> extends never ? Value : Exclude<Types[Key], ExcludedTypes> : Value;
type SyncOrAsync<T> = T | Promise<T>;

type HttpMethodsType = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
type HttpStatusType = number;

type ExtractAdapterOptionsType<T> = T extends Adapter<infer O, any, any, any, any, any, any, any, any, any, any> ? O : never;
type ExtractAdapterMethodType<T> = T extends Adapter<any, infer M, any, any, any, any, any, any, any, any, any> ? M : never;
type ExtractAdapterStatusType<T> = T extends Adapter<any, any, infer S, any, any, any, any, any, any, any, any> ? S : never;
type ExtractAdapterExtraType<T> = T extends Adapter<any, any, any, infer A, any, any, any, any, any, any, any> ? A : never;
type ExtractAdapterQueryParamsType<T> = T extends Adapter<any, any, any, any, infer Q, any, any, any, any, any, any> ? Q : never;
type ExtractAdapterDefaultQueryParamsType<T> = T extends Adapter<any, any, any, any, any, infer Q, any, any, any, any, any> ? Q : never;
type ExtractAdapterEndpointType<T> = T extends Adapter<any, any, any, any, any, any, infer E, any, any, any, any> ? E : never;
type ExtractAdapterEndpointMapperType<T> = T extends Adapter<any, any, any, any, any, any, any, infer EM, any, any, any> ? EM : never;
type ExtractAdapterQueryParamsMapperType<T> = T extends Adapter<any, any, any, any, any, any, any, any, infer QPM, any, any> ? QPM : never;
type ExtractAdapterHeaderMapperType<T> = T extends Adapter<any, any, any, any, any, any, any, any, any, infer HM, any> ? HM : never;
type ExtractAdapterPayloadMapperType<T> = T extends Adapter<any, any, any, any, any, any, any, any, any, any, infer PM> ? PM : never;
type ExtractUnionAdapter<AdapterType extends AdapterInstance, Values extends {
    method?: any;
    options?: any;
    status?: any;
    extra?: any;
    queryParams?: any;
    endpointType?: any;
    defaultQueryParams?: any;
}> = Extract<AdapterType, Adapter<Values["options"], Values["method"], Values["status"], Values["extra"], Values["queryParams"], Values["defaultQueryParams"], Values["endpointType"]>> extends AdapterInstance ? Extract<AdapterType, Adapter<Values["options"], Values["method"], Values["status"], Values["extra"], Values["queryParams"], Values["defaultQueryParams"], Values["endpointType"]>> : never;

type ExtractClientGlobalError<T extends ClientInstance> = T extends Client$1<infer P, any> ? P : never;
type ExtractClientAdapterType<T extends ClientInstance> = T extends Client$1<any, infer P> ? P : never;

type ExtractAdapterResolvedType<T extends RequestInstance> = ResponseType<ExtractResponseType<T>, ExtractErrorType<T>, ExtractAdapterType<T>>;
type ExtractResponseType<T> = T extends Request<infer D, any, any, any, any, any, any, any, any> ? D : never;
type ExtractPayloadType<T> = T extends Request<any, infer D, any, any, any, any, any, any, any> ? D : never;
type ExtractQueryParamsType<T> = T extends Request<any, any, infer Q, any, any, any, any, any, any> ? Q : never;
type ExtractErrorType<T> = T extends Request<any, any, any, infer G, any, infer C, any, any, any> ? G | ExtractClientGlobalError<C> : never;
type ExtractGlobalErrorType<T> = T extends Request<any, any, any, any, any, infer C, any, any, any> ? ExtractClientGlobalError<C> : never;
type ExtractLocalErrorType<T> = T extends Request<any, any, any, infer E, any, any, any, any, any> ? E : never;
type ExtractParamsType<T> = T extends Request<any, any, any, any, infer E, any, any, any, any> ? E extends string ? ExtractUrlParams<E> : never : never;
type ExtractEndpointType<T> = T extends Request<any, any, any, any, infer E, any, any, any, any> ? E : never;
type ExtractClientType<T> = T extends Request<any, any, any, any, any, infer C, any, any, any> ? C : never;
type ExtractAdapterType<T> = T extends Request<any, any, any, any, any, infer C, any, any, any> ? ExtractClientAdapterType<C> : never;
type ExtractHasPayloadType<T> = T extends Request<any, any, any, any, any, any, infer D, any, any> ? D : never;
type ExtractHasParamsType<T> = T extends Request<any, any, any, any, any, any, any, infer P, any> ? P : never;
type ExtractHasQueryParamsType<T> = T extends Request<any, any, any, any, any, any, any, any, infer Q> ? Q : never;
type ExtendRequest<Req extends RequestInstance, Properties extends {
    response?: any;
    payload?: any;
    queryParams?: any;
    globalError?: any;
    localError?: any;
    endpoint?: ExtractAdapterEndpointType<ExtractAdapterType<Req>>;
    client?: Client$1<any, any>;
    hasData?: true | false;
    hasParams?: true | false;
    hasQuery?: true | false;
}> = Request<TypeWithDefaults<Properties, "response", ExtractResponseType<Req>>, TypeWithDefaults<Properties, "payload", ExtractPayloadType<Req>>, TypeWithDefaults<Properties, "queryParams", ExtractQueryParamsType<Req>>, TypeWithDefaults<Properties, "localError", ExtractLocalErrorType<Req>>, Properties["endpoint"] extends string ? Properties["endpoint"] : ExtractEndpointType<Req>, Properties["client"] extends ClientInstance ? Properties["client"] : ExtractClientType<Req>, Properties["hasData"] extends true ? true : ExtractHasPayloadType<Req>, Properties["hasParams"] extends true ? true : ExtractHasParamsType<Req>, Properties["hasQuery"] extends true ? true : ExtractHasQueryParamsType<Req>>;

/**
 * Cache class handles the data exchange with the dispatchers.
 *
 * @note
 * Keys used to save the values are created dynamically on the Request class
 *
 */
declare class Cache<Adapter extends AdapterInstance> {
    options?: CacheOptionsType | undefined;
    emitter: EventEmitter;
    events: ReturnType<typeof getCacheEvents>;
    storage: CacheStorageType;
    lazyStorage?: CacheAsyncStorageType;
    version: string;
    garbageCollectors: Map<string, NodeJS.Timeout>;
    private logger;
    private client;
    constructor(options?: CacheOptionsType | undefined);
    initialize: (client: ClientInstance<{
        adapter: Adapter;
    }>) => this;
    /**
     * Set the cache data to the storage
     * @param request
     * @param response
     * @returns
     */
    set: <Request extends RequestCacheType<RequestInstance>>(request: Request, response: CacheSetState<ResponseType<ExtractResponseType<Request>, ExtractErrorType<Request>, ExtractAdapterType<Request>> & ResponseDetailsType> & {
        hydrated?: boolean;
    }) => void;
    /**
     * Update the cache data with partial response data
     * @param request
     * @param partialResponse
     * @param isTriggeredExtrenally - informs whether an update was triggered due to internal logic or externally, e.g.
     * via plugin.
     * @returns
     */
    update: <Request extends RequestCacheType<RequestInstance>>(request: Request, partialResponse: CacheSetState<Partial<ResponseType<ExtractResponseType<Request>, ExtractErrorType<Request>, ExtractAdapterType<Request>> & ResponseDetailsType>>) => void;
    /**
     * Get particular record from storage by cacheKey. It will trigger lazyStorage to emit lazy load event for reading it's data.
     * @param cacheKey
     * @returns
     */
    get: <Response, Error>(cacheKey: string) => CacheValueType<Response, Error, Adapter> | undefined;
    /**
     * Get sync storage keys, lazyStorage keys will not be included
     * @returns
     */
    keys: () => string[];
    /**
     * Delete record from storages and trigger invalidation event
     * @param cacheKey
     */
    delete: (cacheKey: string) => void;
    /**
     * Invalidate cache by cacheKey or partial matching with RegExp
     * It emits invalidation event for each matching cacheKey and sets staleTime to 0 to indicate out of time cache
     * @param key - cacheKey or Request instance or RegExp for partial matching
     */
    invalidate: (cacheKeys: string | RegExp | RequestInstance | Array<string | RegExp | RequestInstance>) => void;
    /**
     * Used to receive data from lazy storage
     * @param cacheKey
     */
    getLazyResource: <Response, Error>(cacheKey: string) => Promise<CacheValueType<Response, Error, Adapter> | undefined>;
    /**
     * Used to receive keys from sync storage and lazy storage
     * @param cacheKey
     */
    getLazyKeys: () => Promise<string[]>;
    /**
     * Used to receive keys from sync storage and lazy storage
     * @param cacheKey
     */
    getAllKeys: () => Promise<string[]>;
    /**
     * Schedule garbage collection for given key
     * @param cacheKey
     * @returns
     */
    scheduleGarbageCollector: (cacheKey: string) => void;
    /**
     * Clear cache storages
     */
    clear: () => Promise<void>;
}

type CacheOptionsType = {
    /**
     * Assign your custom sync storage
     */
    storage?: CacheStorageType;
    /**
     * Lazy loading from remote resources - possibly persistent
     */
    lazyStorage?: CacheAsyncStorageType;
    /**
     * Key to clear lazy storage data, often used for versioning
     * If the new key is different from the old one, the cache will be cleared
     */
    version?: string;
};
type CacheValueType<Response = any, Error = any, Adapter extends AdapterInstance = AdapterInstance> = ResponseType<Response, Error, Adapter> & ResponseDetailsType & {
    cacheKey: string;
    staleTime: number;
    version: string;
    cacheTime: number;
    cached: boolean;
    hydrated?: boolean;
};
type CacheAsyncStorageType = {
    set: <Response, Error, Adapter extends AdapterInstance>(key: string, data: CacheValueType<Response, Error, Adapter>) => Promise<void>;
    get: <Response, Error, Adapter extends AdapterInstance>(key: string) => Promise<CacheValueType<Response, Error, Adapter> | undefined>;
    keys: () => Promise<string[] | IterableIterator<string> | string[]>;
    delete: (key: string) => Promise<void>;
};
type CacheStorageType = {
    set: <Response, Error, Adapter extends AdapterInstance>(key: string, data: CacheValueType<Response, Error, Adapter>) => void;
    get: <Response, Error, Adapter extends AdapterInstance>(key: string) => CacheValueType<Response, Error, Adapter> | undefined;
    keys: () => string[] | IterableIterator<string> | string[];
    delete: (key: string) => void;
    clear: () => void;
};
type CacheInitialData = Record<string, CacheValueType>;
type CacheSetState<CacheData> = CacheData | ((previousData: CacheData | null) => CacheData);
type RequestCacheType<R extends RequestInstance> = Pick<R, "cacheKey" | "cache" | "staleTime" | "cacheTime">;

declare const getCacheData: <T extends RequestInstance>(previousResponse: ExtractAdapterResolvedType<T> | undefined, response: ExtractAdapterResolvedType<T> & ResponseDetailsType) => ExtractAdapterResolvedType<T> & ResponseDetailsType;
declare const getInvalidateKey: () => string;
declare const getInvalidateByKey: (key: string) => string;
declare const getDeleteKey: () => string;
declare const getDeleteByKey: (key: string) => string;
declare const getCacheByKey: (key: string) => string;
declare const getCacheKey: () => string;

declare const getCacheEvents: (emitter: EventEmitter$1) => {
    /**
     * Set cache data
     * @param data
     */
    emitCacheData: <Response, Error, Adapter extends AdapterInstance>(data: CacheValueType<Response, Error, Adapter> & {
        cached: boolean;
    }, isTriggeredExternally?: boolean) => void;
    /**
     * Invalidate cache values event
     */
    emitInvalidation: (cacheKey: string, isTriggeredExternally?: boolean) => void;
    /**
     * Delete of cache values
     */
    emitDelete: (cacheKey: string, isTriggeredExternally?: boolean) => void;
    /**
     * Cache data listener
     * @param callback
     * @returns
     */
    onData: <Response, Error, Adapter extends AdapterInstance>(callback: (data: CacheValueType<Response, Error, Adapter> & {
        cached: boolean;
    }) => void) => VoidFunction;
    /**
     * Cache data listener
     * @param cacheKey
     * @param callback
     * @returns
     */
    onDataByKey: <Response, Error, Adapter extends AdapterInstance>(cacheKey: string, callback: (data: CacheValueType<Response, Error, Adapter>) => void) => VoidFunction;
    /**
     * Cache invalidation listener
     * @param callback
     * @returns
     */
    onInvalidate: (callback: (cacheKey: string) => void) => VoidFunction;
    /**
     * Cache invalidation listener
     * @param cacheKey
     * @param callback
     * @returns
     */
    onInvalidateByKey: (cacheKey: string, callback: () => void) => VoidFunction;
    onDelete: (callback: (cacheKey: string) => void) => VoidFunction;
    onDeleteByKey: (cacheKey: string, callback: () => void) => VoidFunction;
};

type HydrationOptions = RequestCacheType<RequestInstance> & {
    override: boolean;
};
type HydrateDataType<Data = any, Error = any, Adapter extends AdapterInstance = any> = HydrationOptions & {
    /** Hydration timestamp */
    timestamp: number;
    /** Hydrated response */
    response: ResponseType<Data, Error, Adapter>;
    /** Hydrated flag */
    hydrated: true;
};

declare const getAdapterBindings: <T extends AdapterInstance>({ request: baseRequest, requestId, resolve, onStartTime, internalErrorMapping, }: {
    request: RequestInstance;
    requestId: string;
    resolve: (value: ResponseSuccessType<any, T> | ResponseErrorType<any, T>) => void;
    onStartTime: (timestamp: number) => void;
    internalErrorMapping: (error: ReturnType<typeof getErrorMessage>) => any;
}) => Promise<{
    request: RequestInstance;
    requestId: string;
    url: string;
    endpoint: any;
    queryParams: any;
    payload: any;
    headers: any;
    adapter: AdapterInstance;
    adapterOptions: ExtractAdapterOptionsType<T> | undefined;
    getAbortController: () => AbortController | undefined;
    getRequestStartTimestamp: () => number | null;
    getResponseStartTimestamp: () => number | null;
    createAbortListener: ({ status, extra, onAbort, }: {
        status: ExtractAdapterStatusType<T>;
        extra: ExtractAdapterExtraType<T>;
        onAbort?: () => void;
    }) => () => void;
    onBeforeRequest: () => void;
    onRequestStart: (progress?: ProgressDataType) => number;
    onRequestProgress: (progress: ProgressDataType) => number;
    onRequestEnd: () => number;
    onResponseStart: (progress?: ProgressDataType) => number;
    onResponseProgress: (progress: ProgressDataType) => number;
    onResponseEnd: () => number;
    onSuccess: ({ data, error, status, extra, }: {
        data: any;
        status: ExtractAdapterStatusType<T>;
        extra: ExtractAdapterExtraType<T>;
        error?: ExtractErrorType<T>;
    }) => Promise<ResponseSuccessType<ExtractResponseType<T>, T>>;
    onAbortError: ({ status, extra, }: {
        status: ExtractAdapterStatusType<T>;
        extra: ExtractAdapterExtraType<T>;
    }) => Promise<ResponseErrorType<any, T>>;
    onTimeoutError: ({ status, extra, }: {
        status: ExtractAdapterStatusType<T>;
        extra: ExtractAdapterExtraType<T>;
    }) => Promise<ResponseErrorType<any, T>>;
    onUnexpectedError: ({ status, extra, }: {
        status: ExtractAdapterStatusType<T>;
        extra: ExtractAdapterExtraType<T>;
    }) => Promise<ResponseErrorType<any, T>>;
    onError: ({ error, status, extra, }: {
        error: any;
        status: ExtractAdapterStatusType<T>;
        extra: ExtractAdapterExtraType<T>;
    }) => Promise<ResponseErrorType<any, T>>;
}>;
declare function getAdapterOnError<T extends AdapterInstance>({ request, requestId, startTime, resolve, logger, }: {
    request: RequestInstance;
    requestId: string;
    startTime: number;
    logger: LoggerMethods;
    resolve: (value: ResponseSuccessType<any, T> | ResponseErrorType<any, T>) => void;
}): ({ error, status, extra, }: {
    error: any;
    status: ExtractAdapterStatusType<T>;
    extra: ExtractAdapterExtraType<T>;
}) => Promise<ResponseErrorType<any, T>>;

/**
 * Base Adapter
 */
type AdapterInstance = Adapter<any, any, any, any, any, any, any, any, any, any, any>;
type AdapterGenericType<AdapterOptions, MethodType extends string, StatusType extends number | string, Extra extends Record<string, any>, QueryParams = QueryParamsType | string | EmptyTypes, DefaultQueryParams = undefined, EndpointType = string, EndpointMapperType extends EndpointMapper<EndpointType> | DefaultMapperType = DefaultMapperType, QueryParamsMapperType extends QueryParamsMapper<QueryParams> | DefaultMapperType = DefaultMapperType, HeaderMapperType extends HeaderMappingType | DefaultMapperType = DefaultMapperType, PayloadMapperType extends AdapterPayloadMappingType | DefaultMapperType = DefaultMapperType> = {
    adapterOptions: AdapterOptions;
    methodType: MethodType;
    statusType: StatusType;
    extra: Extra;
    queryParams?: QueryParams;
    defaultQueryParams?: DefaultQueryParams;
    endpointType: EndpointType;
    endpointMapperType?: EndpointMapperType;
    queryParamsMapperType?: QueryParamsMapperType;
    headerMapperType?: HeaderMapperType;
    payloadMapperType?: PayloadMapperType;
};
type DeclareAdapterType<Properties extends AdapterGenericType<any, any, any, any, any, any, any, any, any, any>> = Adapter<TypeWithDefaults<Properties, "adapterOptions", any>, TypeWithDefaults<Properties, "methodType", any>, TypeWithDefaults<Properties, "statusType", any>, TypeWithDefaults<Properties, "extra", any>, TypeWithDefaults<Properties, "queryParams", QueryParamsType | string | EmptyTypes>, TypeWithDefaults<Properties, "defaultQueryParams", undefined>, TypeWithDefaults<Properties, "endpointType", string>, TypeWithDefaults<Properties, "endpointMapperType", DefaultMapperType>, TypeWithDefaults<Properties, "queryParamsMapperType", DefaultMapperType>, TypeWithDefaults<Properties, "headerMapperType", DefaultMapperType>, NonNullable<TypeWithDefaults<Properties, "payloadMapperType", DefaultMapperType>>>;
type AdapterFetcherType<Adapter extends AdapterInstance> = (options: Omit<Awaited<ReturnType<typeof getAdapterBindings<Adapter>>>, "payload"> & {
    url: string;
    endpoint: ReturnType<ExtractAdapterEndpointMapperType<Adapter>>;
    queryParams: ReturnType<ExtractAdapterQueryParamsMapperType<Adapter>>;
    headers: ReturnType<ExtractAdapterHeaderMapperType<Adapter>>;
    payload: ReturnType<ExtractAdapterPayloadMapperType<Adapter>>;
    requestId: string;
    request: RequestInstance;
}) => void;
type HeaderMappingType<Config = never> = (request: RequestInstance, config?: Config) => HeadersInit;
type EndpointMapper<EndpointType, Config = never> = (endpoint: EndpointType, config?: Config) => string;
type QueryParamsMapper<QueryParams, Config = never> = (queryParams: QueryParams | EmptyTypes, config?: Config) => any;
type AdapterPayloadMappingType<Config = never> = (options: {
    request: RequestInstance;
    payload: unknown;
}, config?: Config) => any;
type DefaultEndpointMapper = (endpoint: string) => string;
type DefaultQueryParamsMapper = (queryParams: QueryParamsType | string | EmptyTypes) => QueryParamsType | string | EmptyTypes;
type DefaultHeaderMapper = (request: RequestInstance) => HeadersInit;
type DefaultPayloadMapper = (options: {
    request: RequestInstance;
    payload: unknown;
}) => string;
type QueryParamValuesType = number | string | boolean | null | undefined | Record<any, any>;
type QueryParamType = QueryParamValuesType | Array<QueryParamValuesType> | Record<string, QueryParamValuesType>;
type QueryParamsType = Record<string, QueryParamType>;
type RequestResponseType<Request extends RequestInstance> = {
    data: ExtractResponseType<Request> | null;
    error: ExtractErrorType<Request> | null;
    status: ExtractAdapterStatusType<ExtractAdapterType<Request>> | null;
    success: true | false;
    extra: ExtractAdapterExtraType<ExtractAdapterType<Request>> | null;
    responseTimestamp: number;
    requestTimestamp: number;
};
type ResponseType<GenericDataType, GenericErrorType, Adapter extends AdapterInstance> = {
    data: GenericDataType | null;
    error: GenericErrorType | null;
    status: ExtractAdapterStatusType<Adapter> | null;
    success: true | false;
    extra: ExtractAdapterExtraType<Adapter> | null;
    responseTimestamp: number;
    requestTimestamp: number;
};
type ResponseSuccessType<GenericDataType, Adapter extends AdapterInstance> = {
    data: GenericDataType;
    error: null;
    status: ExtractAdapterStatusType<Adapter> | null;
    success: true;
    extra: ExtractAdapterExtraType<Adapter> | null;
    responseTimestamp: number;
    requestTimestamp: number;
};
type ResponseErrorType<GenericErrorType, Adapter extends AdapterInstance> = {
    data: null;
    error: GenericErrorType;
    status: ExtractAdapterStatusType<Adapter> | null;
    success: false;
    extra: ExtractAdapterExtraType<Adapter> | null;
    responseTimestamp: number;
    requestTimestamp: number;
};
type ProgressDataType = {
    /** Total size in bytes */
    total?: number;
    /** Loaded size in bytes */
    loaded?: number;
};
type ProgressType = {
    /** Progress in percentage (0-100) */
    progress: number;
    /** Time left in seconds (null if not available) */
    timeLeft: number | null;
    /** Size left in bytes */
    sizeLeft: number;
    /** Total size in bytes */
    total: number;
    /** Loaded size in bytes */
    loaded: number;
    /** Start timestamp in milliseconds */
    startTimestamp: number;
};

declare class TimeoutError extends Error {
    constructor();
}
declare class AbortError extends Error {
    constructor();
}
declare class DeletedError extends Error {
    constructor();
}
declare class RequestProcessingError extends Error {
    description?: string;
    constructor(description?: string);
}
declare class UnexpectedError extends Error {
    description?: string;
    constructor(description?: string);
}
declare const getErrorMessage: (errorCase?: "timeout" | "abort" | "deleted" | "processing" | "unexpected") => TimeoutError | AbortError | DeletedError | RequestProcessingError | UnexpectedError;
declare const stringifyValue: (response: string | unknown) => string;
declare const getAdapterHeaders: (request: RequestInstance) => HeadersInit;
declare const getAdapterPayload: (data: unknown) => string | FormData;

type DefaultMapperType = <V, C>(value: V, config: C) => V;
declare const defaultMapper: DefaultMapperType;
declare class Adapter<AdapterOptions, MethodType extends string, StatusType extends number | string, Extra extends Record<string, any>, QueryParams = QueryParamsType | string | EmptyTypes, DefaultQueryParams = undefined, EndpointType = string, EndpointMapperType extends EndpointMapper<EndpointType> | DefaultMapperType = DefaultMapperType, QueryParamsMapperType extends QueryParamsMapper<QueryParams> | DefaultMapperType = DefaultMapperType, HeaderMapperType extends HeaderMappingType | DefaultMapperType = DefaultMapperType, PayloadMapperType extends AdapterPayloadMappingType | DefaultMapperType = DefaultMapperType> {
    options: {
        name: string;
        defaultMethod: MethodType;
        defaultExtra: Extra;
        systemErrorStatus: StatusType;
        systemErrorExtra: Extra;
        defaultRequestOptions?: RequestOptionsType<EndpointType, AdapterOptions, MethodType>;
    };
    /** Fetching function */
    unstable_fetcher: AdapterFetcherType<Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, HeaderMapperType, PayloadMapperType>>;
    /**
     * ********************
     * Defaults
     * ********************
     */
    name: string;
    defaultMethod: MethodType;
    defaultExtra: Extra;
    systemErrorStatus: StatusType;
    systemErrorExtra: Extra;
    defaultRequestOptions?: RequestOptionsType<EndpointType, AdapterOptions, MethodType>;
    logger: LoggerMethods;
    initialized: boolean;
    client: ClientInstance;
    unstable_onInitializeCallback?: (options: {
        client: ClientInstance;
    }) => void;
    unstable_queryParamsMapperConfig: Parameters<QueryParamsMapperType>[1];
    unstable_headerMapperConfig: Parameters<HeaderMapperType>[1];
    unstable_payloadMapperConfig: Parameters<PayloadMapperType>[1];
    unstable_endpointMapperConfig: Parameters<EndpointMapperType>[1];
    constructor(options: {
        name: string;
        defaultMethod: MethodType;
        defaultExtra: Extra;
        systemErrorStatus: StatusType;
        systemErrorExtra: Extra;
        defaultRequestOptions?: RequestOptionsType<EndpointType, AdapterOptions, MethodType>;
    });
    initialize: (client: ClientInstance) => this;
    onInitialize: (callback: (options: {
        client: ClientInstance;
    }) => void) => this;
    /**
     * ********************
     * Options Setters
     * ********************
     */
    unstable_internalErrorMapping: (error: ReturnType<typeof getErrorMessage>) => any;
    /** Method to get default headers and to map them based on the data format exchange, by default it handles FormData / JSON formats. */
    unstable_headerMapper: HeaderMapperType;
    /** Method to get request data and transform them to the required format. It handles FormData and JSON by default. */
    unstable_payloadMapper: PayloadMapperType;
    /** Method to get the endpoint for the adapter request. */
    unstable_endpointMapper: EndpointMapperType;
    /** Method to get request data and transform them to the required format.  */
    unstable_queryParamsMapper: QueryParamsMapperType;
    /** Get default adapter options for the request. */
    unstable_getAdapterDefaults?: (request: ExtendRequest<RequestInstance, {
        client: Client$1<any, Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, HeaderMapperType, PayloadMapperType>>;
    }>) => AdapterOptions;
    /** Get default request options for the request. */
    unstable_getRequestDefaults?: (options: RequestOptionsType<EndpointType, AdapterOptions, MethodType>) => Partial<RequestOptionsType<EndpointType, AdapterOptions, MethodType>>;
    /**
     * Get formatted endpoint name of the request.
     * Helpful in displaying long endpoints like in case of graphql schemas etc.
     */
    unstable_devtoolsEndpointGetter: (endpoint: string) => string;
    /**
     * ********************
     * Methods
     * ********************
     */
    setDefaultMethod: (method: MethodType) => this;
    setDefaultExtra: (extra: Extra) => this;
    setDevtoolsEndpointGetter: (callback: (endpoint: string) => string) => this;
    /**
     * This method allows to configure global defaults for the request configuration like method, auth, deduplication etc.
     */
    setRequestDefaults: (callback: typeof this.unstable_getRequestDefaults) => this;
    /**
     * Set the adapter default options added to every sent request
     */
    setAdapterDefaults: (callback: (request: ExtendRequest<RequestInstance, {
        client: Client$1<any, Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, HeaderMapperType, PayloadMapperType>>;
    }>) => AdapterOptions) => this;
    setInternalErrorMapping: (callback: (error: ReturnType<typeof getErrorMessage>) => any) => this;
    /**
     * Set the custom header mapping function
     */
    setHeaderMapper: <NewMapper extends HeaderMappingType>(headerMapper: NewMapper) => Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, NewMapper, PayloadMapperType>;
    /**
     * Set the request payload mapping function which gets triggered before request is send
     */
    setPayloadMapper: <NewMapper extends AdapterPayloadMappingType>(payloadMapper: NewMapper) => Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, HeaderMapperType, NewMapper>;
    /**
     * Set the request payload mapping function which get triggered before request get sent
     */
    setEndpointMapper: <NewEndpointMapper extends EndpointMapper<EndpointType>>(endpointMapper: NewEndpointMapper) => Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, NewEndpointMapper, QueryParamsMapperType, HeaderMapperType, PayloadMapperType>;
    /**
     * Set the query params mapping function which get triggered before request get sent
     */
    setQueryParamsMapper: <NewQueryParamsMapper extends QueryParamsMapper<QueryParams>>(queryParamsMapper: NewQueryParamsMapper) => Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, NewQueryParamsMapper, HeaderMapperType, PayloadMapperType>;
    setQueryParamsMapperConfig: <NewQueryParamsMapperConfig extends Parameters<QueryParamsMapperType>[1]>(config: NewQueryParamsMapperConfig) => this;
    setHeaderMapperConfig: <NewHeaderMapperConfig extends Parameters<HeaderMapperType>[1]>(config: NewHeaderMapperConfig) => this;
    setEndpointMapperConfig: <NewEndpointMapperConfig extends Parameters<EndpointMapperType>[1]>(config: NewEndpointMapperConfig) => this;
    setPayloadMapperConfig: <NewPayloadMapperConfig extends Parameters<PayloadMapperType>[1]>(config: NewPayloadMapperConfig) => this;
    /**
     * ********************
     * Fetching
     * ********************
     */
    setFetcher(fetcher: AdapterFetcherType<Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, HeaderMapperType, PayloadMapperType>>): this;
    fetch(request: ExtendRequest<RequestInstance, {
        client: Client$1<any, Adapter<AdapterOptions, MethodType, StatusType, Extra, QueryParams, DefaultQueryParams, EndpointType, EndpointMapperType, QueryParamsMapperType, HeaderMapperType, PayloadMapperType>>;
    }>, requestId: string): Promise<RequestResponseType<RequestInstance>>;
}

declare const mocker: <T extends AdapterInstance>({ request, requestId, onError, onResponseEnd, onTimeoutError, onRequestEnd, createAbortListener, onResponseProgress, onRequestProgress, onResponseStart, onBeforeRequest, onRequestStart, onSuccess, onAbortError, adapter, }: Awaited<ReturnType<typeof getAdapterBindings<T>>>) => Promise<void>;

type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type MockerConfigType = {
    /** Informs how long the request should take before returning a timeout error (in milliseconds) */
    timeout?: number;
    /** Simulates how long the request to the server should take (in milliseconds) */
    requestTime?: number;
    /** Indicates how long the response from the server should take (in milliseconds).
     * If their combined total takes longer than provided timeout, each value will be automatically
     * adjusted to last half of the timeout time */
    responseTime?: number;
    /** total number of 'bytes' to be uploaded. */
    totalUploaded?: number;
    /** total number of 'bytes' to be downloaded. */
    totalDownloaded?: number;
};
type MockResponseType<Response, Error, AdapterType extends AdapterInstance> = PartialBy<Omit<ResponseType<Response, Error, AdapterType>, "data" | "error" | "responseTimestamp" | "requestTimestamp">, "extra" | "success"> & ({
    data: Response;
    error?: Error;
} | {
    data?: Response;
    error: Error;
});

/**
 * Request is a class that represents a request sent to the server. It contains all the necessary information to make a request, like endpoint, method, headers, data, and much more.
 * It is executed at any time via methods like `send` or `exec`.
 *
 * We can set it up with options like endpoint, method, headers and more.
 * We can choose some of advanced settings like cache, invalidation patterns, concurrency, retries and much, much more.
 *
 * @info We should not use this class directly in the standard development flow.
 * We can initialize it using the `createRequest` method on the **Client** class.
 *
 * @attention The most important thing about the request is that it keeps data in the format that can be dumped.
 * This is necessary for the persistence and different dispatcher storage types.
 * This class doesn't have any callback methods by design and communicate with dispatcher and cache by events.
 *
 * It should be serializable to JSON and deserializable back to the class.
 * Serialization should not affect the result of the request, so it's methods and functional part should be only syntax sugar for given runtime.
 */
declare class Request<Response, Payload, QueryParams, LocalError, Endpoint extends string, Client extends ClientInstance, HasPayload extends true | false = false, HasParams extends true | false = false, HasQuery extends true | false = false> {
    readonly client: Client;
    readonly requestOptions: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>;
    readonly initialRequestConfiguration?: RequestConfigurationType<Payload, Endpoint extends string ? ExtractUrlParams<Endpoint> : never, QueryParams, Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>> | undefined;
    endpoint: Endpoint;
    headers?: HeadersInit;
    auth: boolean;
    method: ExtractAdapterMethodType<ExtractClientAdapterType<Client>>;
    params: ExtractUrlParams<Endpoint> | EmptyTypes;
    payload: PayloadType<Payload>;
    queryParams: QueryParams | EmptyTypes;
    options?: ExtractAdapterOptionsType<ExtractClientAdapterType<Client>> | undefined;
    cancelable: boolean;
    retry: number;
    retryTime: number;
    cacheTime: number;
    cache: boolean;
    staleTime: number;
    queued: boolean;
    offline: boolean;
    abortKey: string;
    cacheKey: string;
    queryKey: string;
    used: boolean;
    deduplicate: boolean;
    deduplicateTime: number | null;
    isMockerEnabled: boolean;
    unstable_mock?: {
        fn: (options: {
            request: RequestInstance;
            requestId: string;
        }) => MockResponseType<Response, LocalError | ExtractClientGlobalError<Client>, ExtractClientAdapterType<Client>>;
        config: MockerConfigType;
    };
    /** @internal */
    unstable_payloadMapper?: PayloadMapperType<Payload>;
    /** @internal */
    unstable_requestMapper?: RequestMapper<any, any>;
    /** @internal */
    unstable_responseMapper?: ResponseMapper<this, ResponseSuccessType<any, any> | ResponseErrorType<any, any>>;
    unstable_hasParams: HasParams;
    unstable_hasPayload: HasPayload;
    unstable_hasQuery: HasQuery;
    private updatedAbortKey;
    private updatedCacheKey;
    private updatedQueryKey;
    constructor(client: Client, requestOptions: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>, initialRequestConfiguration?: RequestConfigurationType<Payload, Endpoint extends string ? ExtractUrlParams<Endpoint> : never, QueryParams, Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>> | undefined);
    setHeaders: (headers: HeadersInit) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setAuth: (auth: boolean) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setParams: <P extends ExtractParamsType<this>>(params: P) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, P extends null ? false : true, HasQuery>;
    setPayload: <P extends Payload>(payload: P) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, P extends null ? false : true, HasParams, HasQuery>;
    setQueryParams: (queryParams: QueryParams) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, true>;
    setOptions: (options: ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, true>;
    setCancelable: (cancelable: boolean) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setRetry: (retry: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>["retry"]) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setRetryTime: (retryTime: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>["retryTime"]) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setCacheTime: (cacheTime: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>["cacheTime"]) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setCache: (cache: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>["cache"]) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setStaleTime: (staleTime: RequestOptionsType<Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>["staleTime"]) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setQueued: (queued: boolean) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setAbortKey: (abortKey: string) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setCacheKey: (cacheKey: string) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setQueryKey: (queryKey: string) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setDeduplicate: (deduplicate: boolean) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setDeduplicateTime: (deduplicateTime: number) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setUsed: (used: boolean) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setOffline: (offline: boolean) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    setMock: (fn: (options: {
        request: Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
        requestId: string;
    }) => SyncOrAsync<MockResponseType<Response, LocalError | ExtractClientGlobalError<Client>, ExtractClientAdapterType<Client>>>, config?: MockerConfigType) => this;
    clearMock: () => this;
    setMockingEnabled: (isMockerEnabled: boolean) => this;
    /**
     * Map data before it gets send to the server
     * @param payloadMapper
     * @returns
     */
    setPayloadMapper: <MappedPayload extends any | Promise<any>>(payloadMapper: (data: Payload) => MappedPayload) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    /**
     * Map request before it gets send to the server
     * @param requestMapper mapper of the request
     * @returns new request
     */
    setRequestMapper: <NewRequest extends RequestInstance>(requestMapper: RequestMapper<this, NewRequest>) => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    /**
     * Map the response to the new interface
     * @param responseMapper our mapping callback
     * @returns new response
     */
    setResponseMapper: <MappedResponse extends ResponseSuccessType<any, any> | ResponseErrorType<any, any>>(responseMapper?: ResponseMapper<this, MappedResponse>) => Request<MappedResponse extends ResponseType<infer R, any, any> ? R : Response, Payload, QueryParams, MappedResponse extends ResponseType<any, infer E, any> ? E : LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    private paramsMapper;
    toJSON(): RequestJSON<this>;
    clone<NewData extends true | false = HasPayload, NewParams extends true | false = HasParams, NewQueryParams extends true | false = HasQuery>(configuration?: RequestConfigurationType<Payload, (typeof this)["params"], QueryParams, Endpoint, ExtractAdapterOptionsType<ExtractClientAdapterType<Client>>, ExtractAdapterMethodType<ExtractClientAdapterType<Client>>>): Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, NewData, NewParams, NewQueryParams>;
    abort: () => Request<Response, Payload, QueryParams, LocalError, Endpoint, Client, HasPayload, HasParams, HasQuery>;
    dehydrate: (config?: {
        /** in case of using adapter without cache we can provide response to dehydrate */
        response?: ResponseType<Response, LocalError | ExtractClientGlobalError<Client>, ExtractClientAdapterType<Client>>;
        /** override cache data */
        override?: boolean;
    }) => HydrateDataType<Response, LocalError | ExtractClientGlobalError<Client>, ExtractClientAdapterType<Client>> | undefined;
    /**
     * Read the response from cache data
     *
     * If it returns error and data at the same time, it means that latest request was failed
     * and we show previous data from cache together with error received from actual request
     */
    read(): ResponseType<Response, LocalError | ExtractClientGlobalError<Client>, ExtractClientAdapterType<Client>> | undefined;
    /**
     * Method to use the request WITHOUT adding it to cache and queues. This mean it will make simple request without queue side effects.
     * @param options
     * @disableReturns
     * @returns
     * ```tsx
     * Promise<[Data | null, Error | null, HttpStatus]>
     * ```
     */
    exec: RequestSendType<this>;
    /**
     * Method used to perform requests with usage of cache and queues
     * @param options
     * @param requestCallback
     * @disableReturns
     * @returns
     * ```tsx
     * Promise<[Data | null, Error | null, HttpStatus]>
     * ```
     */
    send: RequestSendType<this>;
    static fromJSON: <NewResponse, NewPayload, NewQueryParams, NewLocalError, NewEndpoint extends string, NewClient extends ClientInstance, NewHasPayload extends true | false = false, NewHasParams extends true | false = false, NewHasQuery extends true | false = false>(client: NewClient, json: RequestJSON<Request<NewResponse, NewPayload, NewQueryParams, NewLocalError, NewEndpoint, NewClient, NewHasPayload, NewHasParams, NewHasQuery>>) => Request<NewResponse, NewPayload, NewQueryParams, NewLocalError, NewEndpoint, NewClient, NewHasPayload, NewHasParams, NewHasQuery>;
}

type RequestInstanceProperties = {
    response?: any;
    payload?: any;
    error?: any;
    client?: ClientInstance;
    queryParams?: any;
    endpoint?: string;
    hasParams?: boolean;
    hasQueryParams?: boolean;
    hasPayload?: boolean;
};
type RequestInstance<RequestProperties extends RequestInstanceProperties = {
    response?: any;
    payload?: any;
    queryParams?: any;
    error?: any;
    client?: ClientInstance;
}> = Request<TypeWithDefaults<RequestProperties, "response", any>, TypeWithDefaults<RequestProperties, "payload", any>, TypeWithDefaults<RequestProperties, "queryParams", any>, TypeWithDefaults<RequestProperties, "error", any>, TypeWithDefaults<RequestProperties, "endpoint", any>, TypeWithDefaults<RequestProperties, "client", ClientInstance>, TypeWithDefaults<RequestProperties, "hasParams", any>, TypeWithDefaults<RequestProperties, "hasQueryParams", any>, TypeWithDefaults<RequestProperties, "hasPayload", any>>;
type ProgressEventType = {
    total: number;
    loaded: number;
};
/**
 * Dump of the request used to later recreate it
 */
type RequestJSON<Request extends RequestInstance> = {
    requestOptions: RequestOptionsType<ExtractEndpointType<Request>, ExtractAdapterOptionsType<ExtractAdapterType<Request>>, ExtractAdapterMethodType<ExtractAdapterType<Request>>>;
    endpoint: ExtractEndpointType<Request>;
    method: ExtractAdapterMethodType<ExtractAdapterType<Request>>;
    headers?: HeadersInit;
    auth: boolean;
    cancelable: boolean;
    retry: number;
    retryTime: number;
    cacheTime: number;
    cache: boolean;
    staleTime: number;
    queued: boolean;
    offline: boolean;
    disableResponseInterceptors: boolean | undefined;
    disableRequestInterceptors: boolean | undefined;
    options?: ExtractAdapterOptionsType<ExtractAdapterType<Request>>;
    payload: PayloadType<ExtractPayloadType<Request>>;
    params: ExtractParamsType<Request> | EmptyTypes;
    queryParams: ExtractQueryParamsType<Request> | EmptyTypes;
    abortKey: string;
    cacheKey: string;
    queryKey: string;
    used: boolean;
    updatedAbortKey: boolean;
    updatedCacheKey: boolean;
    updatedQueryKey: boolean;
    deduplicate: boolean;
    deduplicateTime: number | null;
    isMockerEnabled: boolean;
    hasMock: boolean;
};
/**
 * Configuration options for request creation
 */
type RequestOptionsType<GenericEndpoint, AdapterOptions, RequestMethods = HttpMethodsType> = {
    /**
     * Determine the endpoint for request request
     */
    endpoint: GenericEndpoint;
    /**
     * Custom headers for request
     */
    headers?: HeadersInit;
    /**
     * Should the onAuth method get called on this request
     */
    auth?: boolean;
    /**
     * Request method picked from method names handled by adapter
     * With default adapter it is GET | POST | PATCH | PUT | DELETE
     */
    method?: RequestMethods;
    /**
     * Should enable cancelable mode in the Dispatcher
     */
    cancelable?: boolean;
    /**
     * Retry count when request is failed
     */
    retry?: number;
    /**
     * Retry time delay between retries
     */
    retryTime?: number;
    /**
     * Should we trigger garbage collection or leave data in memory
     */
    cacheTime?: number;
    /**
     * Should we save the response to cache
     */
    cache?: boolean;
    /**
     * Time for which the cache is considered up-to-date
     */
    staleTime?: number;
    /**
     * Should the requests from this request be send one-by-one
     */
    queued?: boolean;
    /**
     * Do we want to store request made in offline mode for latter use when we go back online
     */
    offline?: boolean;
    /**
     * Disable post-request interceptors
     */
    disableResponseInterceptors?: boolean;
    /**
     * Disable pre-request interceptors
     */
    disableRequestInterceptors?: boolean;
    /**
     * Additional options for your adapter, by default XHR options
     */
    options?: AdapterOptions;
    /**
     * Key which will be used to cancel requests. Autogenerated by default.
     */
    abortKey?: string;
    /**
     * Key which will be used to cache requests. Autogenerated by default.
     */
    cacheKey?: string;
    /**
     * Key which will be used to queue requests. Autogenerated by default.
     */
    queryKey?: string;
    /**
     * Should we deduplicate two requests made at the same time into one
     */
    deduplicate?: boolean;
    /**
     * Time of pooling for the deduplication to be active (default 10ms)
     */
    deduplicateTime?: number;
};
type PayloadMapperType<Payload> = <NewDataType>(payload: Payload) => NewDataType;
type PayloadType<Payload> = Payload | EmptyTypes;
type RequestConfigurationType<Payload, Params, QueryParams, GenericEndpoint extends string, AdapterOptions, MethodsType> = {
    used?: boolean;
    params?: Params | EmptyTypes;
    queryParams?: QueryParams | EmptyTypes;
    payload?: PayloadType<Payload>;
    headers?: HeadersInit;
    updatedAbortKey?: boolean;
    updatedCacheKey?: boolean;
    updatedQueryKey?: boolean;
    updatedEffectKey?: boolean;
} & Partial<NullableKeys<RequestOptionsType<GenericEndpoint, AdapterOptions, MethodsType>>>;
type ParamType = string | number;
type ParamsType = Record<string, ParamType>;
type ExtractUrlParams<T extends string> = string extends T ? EmptyTypes : T extends `${string}:${infer Param}/${infer Rest}` ? {
    [k in Param | keyof ExtractUrlParams<Rest>]: ParamType;
} : T extends `${string}:${infer Param}` ? {
    [k in Param]: ParamType;
} : EmptyTypes;
/**
 * If the request endpoint parameters are not filled it will throw an error
 */
type FetchParamsType<Params, HasParams extends true | false> = Params extends EmptyTypes | void | never ? {
    params?: EmptyTypes;
} : HasParams extends true ? {
    params?: EmptyTypes;
} : {
    params: Params;
};
/**
 * If the request data is not filled it will throw an error
 */
type FetchPayloadType<Payload, HasPayload extends true | false> = Payload extends EmptyTypes | void | never ? {
    payload?: EmptyTypes;
} : HasPayload extends true ? {
    payload?: EmptyTypes;
} : {
    payload: Payload;
};
/**
 * It will check if the query params are already set
 */
type FetchQueryParamsType<QueryParams, HasQuery extends true | false = false> = HasQuery extends true ? {
    queryParams?: EmptyTypes | undefined;
} : HasQuery extends true ? {
    queryParams?: EmptyTypes;
} : QueryParams extends EmptyTypes | void | never ? {
    queryParams?: QueryParams;
} : {
    queryParams: QueryParams;
};
type RequestDynamicSendOptionsType<Request extends RequestInstance> = Omit<Partial<RequestOptionsType<string, ExtractAdapterOptionsType<ExtractAdapterType<Request>>>>, "params" | "data" | "endpoint" | "method"> & {
    dispatcherType?: "auto" | "fetch" | "submit";
};
type RequestSendOptionsType<Request extends RequestInstance> = FetchQueryParamsType<ExtractQueryParamsType<Request>, ExtractHasQueryParamsType<Request>> & FetchParamsType<ExtractParamsType<Request>, ExtractHasParamsType<Request>> & FetchPayloadType<ExtractPayloadType<Request>, ExtractHasPayloadType<Request>> & FetchQueryParamsType<ExtractQueryParamsType<Request>, ExtractHasQueryParamsType<Request>> & RequestSendActionsType<Request> & RequestDynamicSendOptionsType<Request>;
type RequestSendActionsType<Request extends RequestInstance> = {
    onBeforeSent?: (eventData: RequestEventType<Request>) => void;
    onRequestStart?: (eventData: RequestEventType<Request>) => void;
    onResponseStart?: (eventData: RequestEventType<Request>) => void;
    onUploadProgress?: (eventData: RequestProgressEventType<Request>) => void;
    onDownloadProgress?: (eventData: RequestProgressEventType<Request>) => void;
    onResponse?: (eventData: RequestResponseEventType<Request>) => void;
    onRemove?: (eventData: RequestEventType<Request>) => void;
};
type IsNegativeType<T> = void extends T ? EmptyTypes : undefined extends T ? EmptyTypes : null extends T ? EmptyTypes : T;
type RequestSendType<Request extends RequestInstance> = IsNegativeType<RequestSendOptionsType<Request>["payload"]> extends EmptyTypes | void | never ? IsNegativeType<RequestSendOptionsType<Request>["params"]> extends EmptyTypes | void | never ? IsNegativeType<RequestSendOptionsType<Request>["queryParams"]> extends EmptyTypes | void | never ? (options?: RequestSendOptionsType<Request>) => Promise<RequestResponseType<Request>> : (options: RequestSendOptionsType<Request>) => Promise<RequestResponseType<Request>> : (options: RequestSendOptionsType<Request>) => Promise<RequestResponseType<Request>> : (options: RequestSendOptionsType<Request>) => Promise<RequestResponseType<Request>>;
type RequestMapper<Request extends RequestInstance, NewRequest extends RequestInstance> = (request: Request, requestId: string) => NewRequest | Promise<NewRequest>;
type ResponseMapper<Request extends RequestInstance, MappedResponse extends ResponseSuccessType<any, any> | ResponseErrorType<any, any>> = (response: ResponseSuccessType<ExtractResponseType<Request>, ExtractAdapterType<Request>> | ResponseErrorType<ExtractErrorType<Request>, ExtractAdapterType<Request>>) => MappedResponse | Promise<MappedResponse>;

declare enum DispatcherMode {
    ONE_BY_ONE = "one-by-one",
    ALL_AT_ONCE = "all-at-once",
    PREVIOUS_CANCELED = "previous-canceled",
    DEDUPLICATED = "deduplicated"
}

declare const getDispatcherEvents: (emitter: EventEmitter$1) => {
    emitDrained: <Request extends RequestInstance>(values: QueueDataType<Request>, isTriggeredExternally?: boolean) => void;
    emitQueueStatusChanged: <Request extends RequestInstance>(values: QueueDataType<Request>, isTriggeredExternally?: boolean) => void;
    emitQueueChanged: <Request extends RequestInstance>(values: QueueDataType<Request>, isTriggeredExternally?: boolean) => void;
    /**
     * When queue becomes empty
     * @param callback
     * @returns
     */
    onDrained: <Request extends RequestInstance>(callback: (values: QueueDataType<Request>) => void) => VoidFunction;
    /**
     * When queue becomes empty
     * @param queryKey
     * @param callback
     * @returns
     */
    onDrainedByKey: <Request extends RequestInstance>(queryKey: string, callback: (values: QueueDataType<Request>) => void) => VoidFunction;
    /**
     * When queue status change from enabled to paused or vice versa
     * @param callback
     * @returns
     */
    onQueueStatusChange: <Request extends RequestInstance>(callback: (values: QueueDataType<Request>) => void) => VoidFunction;
    /**
     * When queue status change from enabled to paused or vice versa
     * @param queryKey
     * @param callback
     * @returns
     */
    onQueueStatusChangeByKey: <Request extends RequestInstance>(queryKey: string, callback: (values: QueueDataType<Request>) => void) => VoidFunction;
    /**
     * When new elements are added or removed from the queue
     * @param queryKey
     * @param callback
     * @returns
     */
    onQueueChange: <Request extends RequestInstance>(callback: (values: QueueDataType<Request>) => void) => VoidFunction;
    /**
     * When new elements are added or removed from the queue
     * @param queryKey
     * @param callback
     * @returns
     */
    onQueueChangeByKey: <Request extends RequestInstance>(queryKey: string, callback: (values: QueueDataType<Request>) => void) => VoidFunction;
};

/**
 * Dispatcher controls and manages the requests that are going to be executed with adapter. It manages them based on the options provided with request.
 * This class can also run them with different modes like deduplication, cancelation, queueing or run-all-at-once mode. With it's help we can pause,
 * stop, start and cancel requests.
 */
declare class Dispatcher<Adapter extends AdapterInstance> {
    options?: DispatcherOptionsType | undefined;
    emitter: EventEmitter;
    events: {
        emitDrained: <Request extends RequestInstance>(values: QueueDataType<Request>, isTriggeredExternally?: boolean) => void;
        emitQueueStatusChanged: <Request extends RequestInstance>(values: QueueDataType<Request>, isTriggeredExternally?: boolean) => void;
        emitQueueChanged: <Request extends RequestInstance>(values: QueueDataType<Request>, isTriggeredExternally?: boolean) => void;
        onDrained: <Request extends RequestInstance>(callback: (values: QueueDataType<Request>) => void) => VoidFunction;
        onDrainedByKey: <Request extends RequestInstance>(queryKey: string, callback: (values: QueueDataType<Request>) => void) => VoidFunction;
        onQueueStatusChange: <Request extends RequestInstance>(callback: (values: QueueDataType<Request>) => void) => VoidFunction;
        onQueueStatusChangeByKey: <Request extends RequestInstance>(queryKey: string, callback: (values: QueueDataType<Request>) => void) => VoidFunction;
        onQueueChange: <Request extends RequestInstance>(callback: (values: QueueDataType<Request>) => void) => VoidFunction;
        onQueueChangeByKey: <Request extends RequestInstance>(queryKey: string, callback: (values: QueueDataType<Request>) => void) => VoidFunction;
    };
    storage: DispatcherStorageType;
    private requestCount;
    private runningRequests;
    private logger;
    private client;
    constructor(options?: DispatcherOptionsType | undefined);
    initialize: (client: ClientInstance<{
        adapter: Adapter;
    }>) => this;
    /**
     * Start request handling by queryKey
     */
    start: (queryKey: string) => void;
    /**
     * Pause request queue, but do not cancel already started requests
     */
    pause: (queryKey: string) => void;
    /**
     * Stop request queue and cancel all started requests - those will be treated like not started
     */
    stop: (queryKey: string) => void;
    /**
     * Return all
     */
    getQueuesKeys: () => string[];
    /**
     * Return queue state object
     */
    getQueue: <Request extends RequestInstance = RequestInstance>(queryKey: string) => QueueDataType<Request>;
    /**
     * Return request from queue state
     */
    getRequest: <Request extends RequestInstance = RequestInstance>(queryKey: string, requestId: string) => QueueItemType<Request> | undefined;
    /**
     * Get value of the active queue status based on the stopped status
     */
    getIsActiveQueue: (queryKey: string) => boolean;
    /**
     * Add new element to storage
     */
    addQueueItem: <Request extends RequestInstance = RequestInstance>(queryKey: string, element: QueueItemType<Request>) => void;
    /**
     * Set new queue storage value
     */
    setQueue: <Request extends RequestInstance = RequestInstance>(queryKey: string, queue: QueueDataType<Request>) => QueueDataType<Request>;
    /**
     * Clear requests from queue cache
     */
    clearQueue: (queryKey: string) => {
        queryKey: string;
        requests: never[];
        stopped: boolean;
    };
    /**
     * Method used to flush the queue requests
     */
    flushQueue: (queryKey: string) => Promise<void>;
    /**
     * Flush all available requests from all queues
     */
    flush: () => Promise<void>;
    /**
     * Clear all running requests and storage
     */
    clear: () => void;
    /**
     * Start particular request
     */
    startRequest: (queryKey: string, requestId: string) => void;
    /**
     * Stop particular request
     */
    stopRequest: (queryKey: string, requestId: string) => void;
    /**
     * Get currently running requests from all queryKeys
     */
    getAllRunningRequests: () => RunningRequestValueType[];
    /**
     * Get currently running requests
     */
    getRunningRequests: (queryKey: string) => RunningRequestValueType[];
    /**
     * Get running request by id
     */
    getRunningRequest: (queryKey: string, requestId: string) => RunningRequestValueType | undefined;
    /**
     * Add request to the running requests list
     */
    addRunningRequest: (queryKey: string, requestId: string, request: RequestInstance) => RunningRequestValueType;
    /**
     * Get the value based on the currently running requests
     */
    hasRunningRequests: (queryKey: string) => boolean;
    /**
     * Check if request is currently processing
     */
    hasRunningRequest: (queryKey: string, requestId: string) => boolean;
    /**
     * Cancel all started requests, but do NOT remove it from main storage
     */
    cancelRunningRequests: (queryKey: string) => void;
    /**
     * Cancel started request, but do NOT remove it from main storage
     */
    cancelRunningRequest: (queryKey: string, requestId: string) => void;
    /**
     * Delete all started requests, but do NOT clear it from queue and do NOT cancel them
     */
    deleteRunningRequests: (queryKey: string) => void;
    /**
     * Delete request by id, but do NOT clear it from queue and do NOT cancel them
     */
    deleteRunningRequest: (queryKey: string, requestId: string) => void;
    /**
     * Get count of requests from the same queryKey
     */
    getQueueRequestCount: (queryKey: string) => number;
    /**
     * Add request count to the queryKey
     */
    incrementQueueRequestCount: (queryKey: string) => void;
    /**
     * Create storage element from request
     */
    createStorageItem: <Request extends RequestInstance>(request: Request) => QueueItemType<Request>;
    /**
     * Add request to the dispatcher handler
     */
    add: (request: RequestInstance) => string;
    /**
     * Delete from the storage and cancel request
     */
    delete: (queryKey: string, requestId: string, abortKey: string) => QueueDataType<RequestInstance> | undefined;
    /**
     * Request can run for some time, once it's done, we have to check if it's successful or if it was aborted
     * It can be different once the previous call was set as cancelled and removed from queue before this request got resolved
     */
    performRequest: (storageItem: QueueItemType) => Promise<void | QueueDataType<RequestInstance>>;
}

type DispatcherOptionsType = {
    storage?: DispatcherStorageType;
};
type QueueItemType<Request extends RequestInstance = RequestInstance> = {
    requestId: string;
    request: Request;
    retries: number;
    timestamp: number;
    stopped: boolean;
    /** Resolved when we receive response */
    resolved: boolean;
};
type QueueDataType<Request extends RequestInstance = RequestInstance> = {
    queryKey: string;
    requests: QueueItemType<Request>[];
    stopped: boolean;
};
type DispatcherStorageType = {
    set: <Request extends RequestInstance = RequestInstance>(key: string, data: QueueDataType<Request>) => void;
    get: <Request extends RequestInstance = RequestInstance>(key: string) => QueueDataType<Request> | undefined;
    keys: () => string[] | IterableIterator<string>;
    entries: () => [string, QueueDataType] | IterableIterator<[string, QueueDataType<any>]>;
    delete: (key: string) => void;
    clear: () => void;
};
type RunningRequestValueType = {
    requestId: string;
    request: RequestInstance;
    timestamp: number;
};

declare const getDispatcherDrainedKey: () => string;
declare const getDispatcherDrainedByKey: (key: string) => string;
declare const getDispatcherStatusKey: () => string;
declare const getDispatcherStatusByKey: (key: string) => string;
declare const getDispatcherChangeKey: () => string;
declare const getDispatcherChangeByKey: (key: string) => string;
declare const getIsEqualTimestamp: (currentTimestamp: number, threshold: number, queueTimestamp?: number) => boolean;
declare const canRetryRequest: (currentRetries: number, retry: number | undefined) => boolean;
declare const getRequestType: (request: RequestInstance, latestRequest: QueueItemType | undefined) => DispatcherMode;

declare const stringifyKey: (value: unknown) => string;
declare const getProgressValue: ({ loaded, total }: ProgressEventType) => number;
declare const getRequestEta: (startDate: Date, progressDate: Date, { total, loaded }: ProgressEventType) => {
    sizeLeft: number;
    timeLeft: number | null;
};
declare const getProgressData: (requestStartTime: Date, progressDate: Date, progressEvent: ProgressEventType) => ProgressType;
declare const getSimpleKey: (request: RequestInstance | RequestJSON<RequestInstance>) => string;
/**
 * Cache instance for individual request that collects individual requests responses from
 * the same endpoint (they may differ base on the custom key, endpoint params etc)
 * @param request
 * @param useInitialValues
 * @returns
 */
declare const getRequestKey: (request: RequestInstance | RequestJSON<RequestInstance>, useInitialValues?: boolean) => string;
declare const getRequestDispatcher: <Request extends RequestInstance>(request: Request, dispatcherType?: "auto" | "fetch" | "submit") => [Dispatcher<ExtractAdapterType<Request>>, isFetchDispatcher: boolean];
declare const sendRequest: <Request extends RequestInstance>(request: Request, options?: RequestSendOptionsType<Request>) => Promise<RequestResponseType<Request>>;

declare const getUniqueRequestId: (request: Pick<RequestInstance, "queryKey">) => string;

declare class EventEmitter extends EventEmitter$1 {
    emitCallbacks: Array<(event: string, data: any, isTriggeredExternally?: true) => void>;
    constructor(options?: ConstructorParameters<typeof EventEmitter$1>[0]);
    emit(type: string, data: any, isTriggeredExternally: boolean): boolean;
    onEmit: (callback: (event: string, data: any, isTriggeredExternally?: true) => void) => () => void;
    onListener: (event: string, listener: (count: number) => void) => () => void;
    on: (event: string | symbol, listener: (...args: any[]) => void) => this;
    off: (event: string | symbol, listener: (...args: any[]) => void) => this;
    addListener: (event: string | symbol, listener: (...args: any[]) => void) => this;
    removeListener: (event: string | symbol, listener: (...args: any[]) => void) => this;
}

/**
 * App manager handles main application states - focus and online. Those two values can answer questions:
 * - Is the tab or current view instance focused and visible for user?
 * - Is our application online or offline?
 * With the app manager it is not a problem to get the valid answer for this question.
 *
 * @caution
 * Make sure to apply valid focus/online handlers for different environments like for example for native mobile applications.
 */
declare class AppManager {
    options?: AppManagerOptionsType | undefined;
    emitter: EventEmitter;
    events: {
        emitFocus: () => void;
        emitBlur: () => void;
        emitOnline: () => void;
        emitOffline: () => void;
        onFocus: (callback: () => void) => VoidFunction;
        onBlur: (callback: () => void) => VoidFunction;
        onOnline: (callback: () => void) => VoidFunction;
        onOffline: (callback: () => void) => VoidFunction;
    };
    isBrowser: boolean;
    isOnline: boolean;
    isFocused: boolean;
    constructor(options?: AppManagerOptionsType | undefined);
    initialize: () => void;
    private setInitialFocus;
    private setInitialOnline;
    setFocused: (isFocused: boolean) => void;
    setOnline: (isOnline: boolean) => void;
}

type AppManagerOptionsType = {
    initiallyFocused?: boolean | (() => boolean | Promise<boolean>);
    initiallyOnline?: boolean | (() => boolean | Promise<boolean>);
    focusEvent?: (setFocused: (isFocused: boolean) => void) => void;
    onlineEvent?: (setOnline: (isOnline: boolean) => void) => void;
};

declare const hasWindow: () => boolean;
declare const hasDocument: () => boolean;
declare const onWindowEvent: <K extends keyof WindowEventMap>(key: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined) => VoidFunction;
declare const onDocumentEvent: <K extends keyof DocumentEventMap>(key: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined) => VoidFunction;

declare const getAppManagerEvents: (emitter: EventEmitter$1) => {
    emitFocus: () => void;
    emitBlur: () => void;
    emitOnline: () => void;
    emitOffline: () => void;
    onFocus: (callback: () => void) => VoidFunction;
    onBlur: (callback: () => void) => VoidFunction;
    onOnline: (callback: () => void) => VoidFunction;
    onOffline: (callback: () => void) => VoidFunction;
};

declare enum AppEvents {
    FOCUS = "focus",
    BLUR = "blur",
    ONLINE = "online",
    OFFLINE = "offline"
}
declare const appManagerInitialOptions: RequiredKeys<AppManagerOptionsType>;

/**
 * **Request Manager** is used to emit `request lifecycle events` like - request start, request end, upload and download progress.
 * It is also the place of `request aborting` system, here we store all the keys and controllers that are isolated for each client instance.
 */
declare class RequestManager {
    emitter: EventEmitter;
    events: {
        emitDeduplicated: (data: RequestDeduplicatedEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitLoading: (data: RequestLoadingEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitRequestStart: (data: RequestEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitResponseStart: (data: RequestEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitUploadProgress: (data: RequestProgressEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitDownloadProgress: (data: RequestProgressEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitResponse: <Adapter extends AdapterInstance>(data: RequestResponseEventType<ExtendRequest<RequestInstance, {
            client: Client$1<any, Adapter>;
        }>>, isTriggeredExternally?: boolean) => void;
        emitAbort: (data: RequestEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        emitRemove: (data: RequestRemovedEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
        onDeduplicated: <T extends RequestInstance>(callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
        onDeduplicatedByQueue: <T extends RequestInstance>(queryKey: string, callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
        onDeduplicatedByCache: <T extends RequestInstance>(cacheKey: string, callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
        onDeduplicatedById: <T extends RequestInstance>(requestId: string, callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
        onLoading: <T extends RequestInstance>(callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
        onLoadingByQueue: <T extends RequestInstance>(queryKey: string, callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
        onLoadingByCache: <T extends RequestInstance>(cacheKey: string, callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
        onLoadingById: <T extends RequestInstance>(requestId: string, callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
        onRequestStart: <T extends RequestInstance>(callback: (details: RequestEventType<T>) => void) => VoidFunction;
        onRequestStartByQueue: <T extends RequestInstance>(queryKey: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
        onRequestStartById: <T extends RequestInstance>(requestId: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
        onResponseStart: <T extends RequestInstance>(callback: (details: RequestEventType<T>) => void) => VoidFunction;
        onResponseStartByQueue: <T extends RequestInstance>(queryKey: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
        onResponseStartById: <T extends RequestInstance>(requestId: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
        onUploadProgress: <T extends RequestInstance = RequestInstance>(callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
        onUploadProgressByQueue: <T extends RequestInstance = RequestInstance>(queryKey: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
        onUploadProgressById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
        onDownloadProgress: <T extends RequestInstance = RequestInstance>(callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
        onDownloadProgressByQueue: <T extends RequestInstance = RequestInstance>(queryKey: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
        onDownloadProgressById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
        onResponse: <T extends RequestInstance>(callback: (data: RequestResponseEventType<T>) => void) => VoidFunction;
        onResponseByCache: <T extends RequestInstance>(cacheKey: string, callback: (data: RequestResponseEventType<T>) => void) => VoidFunction;
        onResponseById: <T extends RequestInstance>(requestId: string, callback: (data: RequestResponseEventType<T>) => void) => VoidFunction;
        onAbort: <T extends RequestInstance = RequestInstance>(callback: (request: RequestEventType<T>) => void) => VoidFunction;
        onAbortByKey: <T extends RequestInstance = RequestInstance>(abortKey: string, callback: (request: RequestEventType<T>) => void) => VoidFunction;
        onAbortById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestEventType<T>) => void) => VoidFunction;
        onRemove: <T extends RequestInstance = RequestInstance>(callback: (data: RequestRemovedEventType<T>) => void) => VoidFunction;
        onRemoveByQueue: <T extends RequestInstance = RequestInstance>(queryKey: string, callback: (data: RequestRemovedEventType<T>) => void) => VoidFunction;
        onRemoveById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestRemovedEventType<T>) => void) => VoidFunction;
    };
    constructor();
    abortControllers: Map<string, Map<string, AbortController>>;
    addAbortController: (abortKey: string, requestId: string) => void;
    getAbortController: (abortKey: string, requestId: string) => AbortController | undefined;
    removeAbortController: (abortKey: string, requestId: string) => void;
    useAbortController: (abortKey: string, requestId: string) => void;
    abortByKey: (abortKey: string) => void;
    abortByRequestId: (abortKey: string, requestId: string) => void;
    abortAll: () => void;
}

declare const getLoadingKey: () => string;
declare const getLoadingByQueryKey: (queryKey: string) => string;
declare const getLoadingByCacheKey: (cacheKey: string) => string;
declare const getLoadingByIdKey: (id: string) => string;
declare const getRemoveKey: () => string;
declare const getRemoveByQueryKey: (queryKey: string) => string;
declare const getRemoveByIdKey: (id: string) => string;
declare const getAbortKey: () => string;
declare const getAbortByAbortKey: (abortKey: string) => string;
declare const getAbortByIdKey: (id: string) => string;
declare const getResponseKey: () => string;
declare const getResponseByCacheKey: (cacheKey: string) => string;
declare const getResponseByIdKey: (id: string) => string;
declare const getRequestStartKey: () => string;
declare const getRequestStarByQueryKey: (queryKey: string) => string;
declare const getRequestStartByIdKey: (id: string) => string;
declare const getResponseStartKey: () => string;
declare const getResponseStartByQueryKey: (queryKey: string) => string;
declare const getResponseStartByIdKey: (id: string) => string;
declare const getUploadProgressKey: () => string;
declare const getUploadProgressByQueryKey: (queryKey: string) => string;
declare const getUploadProgressByIdKey: (id: string) => string;
declare const getDownloadProgressKey: () => string;
declare const getDownloadProgressByQueryKey: (queryKey: string) => string;
declare const getDownloadProgressByIdKey: (id: string) => string;
declare const getRequestDeduplicatedKey: () => string;
declare const getRequestDeduplicatedByQueryKey: (queryKey: string) => string;
declare const getRequestDeduplicatedByCacheKey: (cacheKey: string) => string;
declare const getRequestDeduplicatedByIdKey: (id: string) => string;

declare const getRequestManagerEvents: (emitter: EventEmitter$1) => {
    /**
     * Emiter
     */
    emitDeduplicated: (data: RequestDeduplicatedEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitLoading: (data: RequestLoadingEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitRequestStart: (data: RequestEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitResponseStart: (data: RequestEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitUploadProgress: (data: RequestProgressEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitDownloadProgress: (data: RequestProgressEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitResponse: <Adapter extends AdapterInstance>(data: RequestResponseEventType<ExtendRequest<RequestInstance, {
        client: Client$1<any, Adapter>;
    }>>, isTriggeredExternally?: boolean) => void;
    emitAbort: (data: RequestEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    emitRemove: (data: RequestRemovedEventType<RequestInstance>, isTriggeredExternally?: boolean) => void;
    /**
     * Listeners
     */
    onDeduplicated: <T extends RequestInstance>(callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
    onDeduplicatedByQueue: <T extends RequestInstance>(queryKey: string, callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
    onDeduplicatedByCache: <T extends RequestInstance>(cacheKey: string, callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
    onDeduplicatedById: <T extends RequestInstance>(requestId: string, callback: (data: RequestDeduplicatedEventType<T>) => void) => VoidFunction;
    onLoading: <T extends RequestInstance>(callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
    onLoadingByQueue: <T extends RequestInstance>(queryKey: string, callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
    onLoadingByCache: <T extends RequestInstance>(cacheKey: string, callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
    onLoadingById: <T extends RequestInstance>(requestId: string, callback: (data: RequestLoadingEventType<T>) => void) => VoidFunction;
    onRequestStart: <T extends RequestInstance>(callback: (details: RequestEventType<T>) => void) => VoidFunction;
    onRequestStartByQueue: <T extends RequestInstance>(queryKey: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
    onRequestStartById: <T extends RequestInstance>(requestId: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
    onResponseStart: <T extends RequestInstance>(callback: (details: RequestEventType<T>) => void) => VoidFunction;
    onResponseStartByQueue: <T extends RequestInstance>(queryKey: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
    onResponseStartById: <T extends RequestInstance>(requestId: string, callback: (details: RequestEventType<T>) => void) => VoidFunction;
    onUploadProgress: <T extends RequestInstance = RequestInstance>(callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
    onUploadProgressByQueue: <T extends RequestInstance = RequestInstance>(queryKey: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
    onUploadProgressById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
    onDownloadProgress: <T extends RequestInstance = RequestInstance>(callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
    onDownloadProgressByQueue: <T extends RequestInstance = RequestInstance>(queryKey: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
    onDownloadProgressById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestProgressEventType<T>) => void) => VoidFunction;
    onResponse: <T extends RequestInstance>(callback: (data: RequestResponseEventType<T>) => void) => VoidFunction;
    onResponseByCache: <T extends RequestInstance>(cacheKey: string, callback: (data: RequestResponseEventType<T>) => void) => VoidFunction;
    onResponseById: <T extends RequestInstance>(requestId: string, callback: (data: RequestResponseEventType<T>) => void) => VoidFunction;
    onAbort: <T extends RequestInstance = RequestInstance>(callback: (request: RequestEventType<T>) => void) => VoidFunction;
    onAbortByKey: <T extends RequestInstance = RequestInstance>(abortKey: string, callback: (request: RequestEventType<T>) => void) => VoidFunction;
    onAbortById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestEventType<T>) => void) => VoidFunction;
    onRemove: <T extends RequestInstance = RequestInstance>(callback: (data: RequestRemovedEventType<T>) => void) => VoidFunction;
    onRemoveByQueue: <T extends RequestInstance = RequestInstance>(queryKey: string, callback: (data: RequestRemovedEventType<T>) => void) => VoidFunction;
    onRemoveById: <T extends RequestInstance = RequestInstance>(requestId: string, callback: (data: RequestRemovedEventType<T>) => void) => VoidFunction;
};

type RequestLoadingEventType<T extends RequestInstance> = {
    loading: boolean;
    isRetry: boolean;
    isOffline: boolean;
} & RequestEventType<T>;
type RequestProgressEventType<T extends RequestInstance> = ProgressType & RequestEventType<T>;
type RequestEventType<T extends RequestInstance> = {
    request: T;
    requestId: string;
};
type RequestRemovedEventType<T extends RequestInstance> = {
    request: T;
    requestId: string;
    /** @true when we receive any response, @false if removed before response is received */
    resolved: boolean;
};
type RequestResponseEventType<T extends RequestInstance> = {
    request: T;
    requestId: string;
    response: ResponseType<ExtractResponseType<T>, ExtractErrorType<T>, ExtractAdapterType<T>>;
    details: ResponseDetailsType;
};
type RequestDeduplicatedEventType<T extends RequestInstance> = RequestEventType<T> & {
    deduplicatedRequest: T;
};
type ResponseDetailsType = {
    /** If it's retry request we can see which attempt is it */
    retries: number;
    /** If request was canceled */
    isCanceled: boolean;
    /** If error from offline status */
    isOffline: boolean;
    /** When added to dispatcher's queue (pre-middleware which could take time) */
    addedTimestamp: number;
    /** When request is picked from queue and started to be sent */
    triggerTimestamp: number;
    /** When adapter triggers request (after all middlewares) */
    requestTimestamp: number;
    /** When we receive response */
    responseTimestamp: number;
};

/**
 * This class is used across the Hyper Fetch library to provide unified logging system with necessary setup per each client.
 * We can set up the logging level based on available values. This manager enable to initialize the logging instance per individual module
 * like Client, Request etc. Which can give you better feedback on the logging itself.
 */
declare class LoggerManager {
    private options?;
    logger: LoggerType;
    level: LogLevel;
    modules: string[] | undefined;
    emitter: EventEmitter$1;
    private client;
    constructor(options?: LoggerOptionsType | undefined);
    setSeverity: (level: LogLevel) => void;
    setModules: (modules: string[] | undefined) => void;
    initialize: (client: Pick<ClientInstance, "debug">, module: string) => LoggerMethods;
    private log;
}

declare const getTime: () => string;
declare const logger: LoggerType;

type LogLevel = "debug" | "info" | "warning" | "error";
type LoggerOptionsType = {
    logger?: LoggerType;
    level?: LogLevel;
    modules?: string[];
};
type LogData<Data extends Record<string, any>> = {
    /** Some Message / https://google.com */
    title: string;
    /** Some contextual data */
    extra: Data;
};
type LoggerArgs = LogDataTypes & {
    /** "debug" | "info" | "warning" | "error" */
    level: LogLevel;
    /** Client / Request / Cache / Dispatcher / useFetch etc. */
    module: string;
};
type LoggerType = (data: LoggerArgs) => void;
type LoggerMethods = Record<LogLevel, (data: LogDataTypes) => void>;
type LogRequestEventType = LogData<{
    request: RequestInstance;
    [key: string]: unknown;
}>;
type LogResponseEventType = LogData<{
    request: RequestInstance;
    response: ResponseType<any, any, AdapterInstance>;
    requestId: string;
    [key: string]: unknown;
}>;
type LogSystemEventType = LogData<{
    [key: string]: unknown;
}>;
type LogDataTypes = ({
    type: "request";
} & LogRequestEventType) | ({
    type: "response";
} & LogResponseEventType) | ({
    type: "system";
} & LogSystemEventType);

declare const logLevelOrder: LogLevel[];
declare const loggerStyles: Record<LogLevel, string>;
declare const loggerColors: Record<LogLevel, string>;

declare const getResponseHeaders: (headersString: string) => Record<string, string>;
declare const parseResponse: (response: string | unknown) => any;
declare const handleResponse: (responseChunks: any[], responseType: HttpAdapterRequest["responseType"], responseEncoding: BufferEncoding) => any;
declare const parseErrorResponse: <T extends RequestInstance>(response: unknown) => ExtractErrorType<T>;
declare const stringifyQueryParams: (queryParams: QueryParamsType | string | EmptyTypes, options?: QueryStringifyOptionsType) => string;

/**
 * Base Adapter
 */
type HttpAdapterType = DeclareAdapterType<{
    adapterOptions: HttpAdapterOptionsType;
    methodType: HttpMethodsType;
    statusType: HttpStatusType;
    extra: HttpAdapterExtraType;
    queryParams: QueryParamsType | string | null;
    endpointType: string;
    queryParamsMapperType: typeof stringifyQueryParams;
}>;
/**
 * Options
 */
interface HttpAdapterRequest extends Omit<XMLHttpRequest, "responseType"> {
    responseType: XMLHttpRequestResponseType | "stream";
}
type HttpAdapterOptionsType = Partial<HttpAdapterRequest>;
type HttpAdapterExtraType = {
    headers: Record<string, string>;
};
type HttpAdapterHeadersProps = {
    isFormData: boolean;
    headers: HeadersInit | undefined;
};
type QueryStringifyOptionsType = {
    /**
     * Strict URI encoding
     */
    strict?: boolean;
    /**
     * Encode keys and values
     */
    encode?: boolean;
    /**
     * Array encoding type
     */
    arrayFormat?: "bracket" | "index" | "comma" | "separator" | "bracket-separator" | "none";
    /**
     * Array format separator
     */
    arraySeparator?: string;
    /**
     * Skip keys with null values
     */
    skipNull?: boolean;
    /**
     * Skip keys with empty string
     */
    skipEmptyString?: boolean;
    /**
     * Parsing function for date type query param
     */
    dateParser?: (value: QueryParamType) => string;
    /**
     * Parsing function for object type query param
     */
    objectParser?: (value: QueryParamType) => string;
};
type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";

declare const HttpAdapter: () => HttpAdapterType;

declare const defaultTimeout: number;
declare const xhrExtra: HttpAdapterExtraType;

/**
 * **Client** is a class that allows you to configure the connection with the server and then use it to create
 * requests. It allows you to set global defaults for the requests configuration, query params configuration.
 * It is also orchestrator for all of the HyperFetch modules like Cache, Dispatcher, AppManager, LoggerManager,
 * RequestManager and more.
 */
declare class Client$1<GlobalErrorType extends ClientErrorType = Error, Adapter extends AdapterInstance = HttpAdapterType> {
    options: ClientOptionsType<Client$1<GlobalErrorType, Adapter>>;
    readonly url: string;
    debug: boolean;
    unstable_onErrorCallbacks: ResponseInterceptorType<ClientInstance>[];
    unstable_onSuccessCallbacks: ResponseInterceptorType<ClientInstance>[];
    unstable_onResponseCallbacks: ResponseInterceptorType<ClientInstance>[];
    unstable_onAuthCallbacks: RequestInterceptorType[];
    unstable_onRequestCallbacks: RequestInterceptorType[];
    loggerManager: LoggerManager;
    requestManager: RequestManager;
    appManager: AppManager;
    adapter: Adapter;
    cache: Cache<Adapter>;
    fetchDispatcher: Dispatcher<Adapter>;
    submitDispatcher: Dispatcher<Adapter>;
    isMockerEnabled: boolean;
    plugins: PluginInstance[];
    /** @internal */
    unstable_abortKeyMapper: (request: RequestInstance) => string;
    /** @internal */
    unstable_cacheKeyMapper: (request: RequestInstance) => string;
    /** @internal */
    unstable_queryKeyMapper: (request: RequestInstance) => string;
    /** @internal */
    unstable_requestIdMapper: (request: RequestInstance) => string;
    logger: LoggerMethods;
    constructor(options: ClientOptionsType<Client$1<GlobalErrorType, Adapter>>);
    /**
     * This method enables the logger usage and display the logs in console
     */
    setDebug: (enabled: boolean) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Set the logger severity of the messages displayed to the console
     */
    setLogLevel: (severity: LogLevel) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Set the new logger instance to the Client
     */
    setLogger: (callback: (Client: ClientInstance) => LoggerManager) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Set globally if mocking should be enabled or disabled for all client requests.
     * @param isMockerEnabled
     */
    setEnableGlobalMocking: (isMockerEnabled: boolean) => this;
    /**
     * Set custom http adapter to handle graphql, rest, firebase or others
     */
    setAdapter: <NewAdapter extends AdapterInstance>(adapter: NewAdapter) => Client$1<GlobalErrorType, NewAdapter>;
    /**
     * Method of manipulating requests before sending the request. We can for example add custom header with token to the request which request had the auth set to true.
     */
    onAuth: (callback: RequestInterceptorType) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for removing listeners on auth.
     * */
    removeOnAuthInterceptors: (callbacks: RequestInterceptorType[]) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for intercepting error responses. It can be used for example to refresh tokens.
     */
    onError: <ErrorType = null>(callback: ResponseInterceptorType<ClientInstance, any, ErrorType | GlobalErrorType>) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for removing listeners on error.
     * */
    removeOnErrorInterceptors: (callbacks: ResponseInterceptorType<ClientInstance, any, null | GlobalErrorType>[]) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for intercepting success responses.
     */
    onSuccess: <ErrorType = null>(callback: ResponseInterceptorType<ClientInstance, any, ErrorType | GlobalErrorType>) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for removing listeners on success.
     * */
    removeOnSuccessInterceptors: (callbacks: ResponseInterceptorType<ClientInstance, any, null | GlobalErrorType>[]) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method of manipulating requests before sending the request.
     */
    onRequest: (callback: RequestInterceptorType) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for removing listeners on request.
     * */
    removeOnRequestInterceptors: (callbacks: RequestInterceptorType[]) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for intercepting any responses.
     */
    onResponse: <ErrorType = null>(callback: ResponseInterceptorType<ClientInstance, any, ErrorType | GlobalErrorType>) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Method for removing listeners on request.
     * */
    removeOnResponseInterceptors: (callbacks: ResponseInterceptorType<ClientInstance, any, null | GlobalErrorType>[]) => Client$1<GlobalErrorType, Adapter>;
    /**
     * Add persistent plugins which trigger on the request lifecycle
     */
    addPlugin: (plugin: PluginInstance) => this;
    /**
     * Remove plugins from Client
     */
    removePlugin: (plugin: PluginInstance) => this;
    triggerPlugins: <Key extends keyof PluginMethods<Client$1>>(key: Key, data: PluginMethodParameters<Key, Client$1>) => this;
    /**
     * Key setters
     */
    setAbortKeyMapper: (callback: (request: RequestInstance) => string) => this;
    setCacheKeyMapper: (callback: (request: RequestInstance) => string) => this;
    setQueryKeyMapper: (callback: (request: RequestInstance) => string) => this;
    setRequestIdMapper: (callback: (request: RequestInstance) => string) => this;
    /**
     * Helper used by http adapter to apply the modifications on response error
     * @private
     */
    unstable_modifyAuth: (request: RequestInstance) => Promise<RequestInstance>;
    /**
     * Private helper to run async pre-request processing
     * @private
     */
    unstable_modifyRequest: (request: RequestInstance) => Promise<RequestInstance>;
    /**
     * Private helper to run async on-error response processing
     * @private
     */
    unstable_modifyErrorResponse: (response: ResponseType<any, GlobalErrorType, Adapter>, request: RequestInstance) => Promise<ResponseType<any, GlobalErrorType, AdapterInstance>>;
    /**
     * Private helper to run async on-success response processing
     * @private
     */
    unstable_modifySuccessResponse: (response: ResponseType<any, GlobalErrorType, Adapter>, request: RequestInstance) => Promise<ResponseType<any, GlobalErrorType, AdapterInstance>>;
    /**
     * Private helper to run async response processing
     * @private
     */
    unstable_modifyResponse: (response: ResponseType<any, GlobalErrorType, Adapter>, request: RequestInstance) => Promise<ResponseType<any, GlobalErrorType, AdapterInstance>>;
    /**
     * Clears the Client instance and remove all listeners on it's dependencies
     */
    clear: () => void;
    /**
     * Hydrate your SSR cache data
     * @param hydrationData
     * @param options
     */
    hydrate: (hydrationData: (HydrateDataType | EmptyTypes)[], options?: Partial<HydrationOptions> | ((item: HydrateDataType) => Partial<HydrationOptions>)) => void;
    /**
     * Create requests based on the Client setup
     *
     * @template Response Your response
     */
    createRequest: <RequestProperties extends RequestGenericType<ExtractAdapterQueryParamsType<Adapter>> = {}>(
    /**
     * `createRequest` must be initialized twice(currying).
     *
     * ✅ Good:
     * ```ts
     * const request = createRequest<RequestProperties>()(params)
     * ```
     * ⛔ Bad:
     * ```ts
     * const request = createRequest<RequestProperties>(params)
     * ```
     *
     * We are using currying to achieve auto generated types for the endpoint string.
     *
     * This solution will be removed once https://github.com/microsoft/TypeScript/issues/10571 get resolved.
     */
    _USE_DOUBLE_INITIALIZATION?: never) => <EndpointType extends ExtractAdapterEndpointType<Adapter>, AdapterOptions extends ExtractAdapterOptionsType<Adapter>, MethodType extends ExtractAdapterMethodType<Adapter>>(params: RequestOptionsType<EndpointType, AdapterOptions, MethodType>) => Request<TypeWithDefaults<RequestProperties, "response", undefined>, TypeWithDefaults<RequestProperties, "payload", undefined>, TypeWithDefaults<RequestProperties, "queryParams", ExtractAdapterDefaultQueryParamsType<Adapter>, never>, TypeWithDefaults<RequestProperties, "error", GlobalErrorType>, TypeWithDefaults<RequestProperties, "endpoint", EndpointType> extends string ? TypeWithDefaults<RequestProperties, "endpoint", EndpointType> : any, Client$1<GlobalErrorType, ExtractUnionAdapter<Adapter, {
        method: MethodType;
        options: AdapterOptions;
        queryParams: TypeWithDefaults<RequestProperties, "queryParams", ExtractAdapterDefaultQueryParamsType<Adapter>, never>;
    }> extends EmptyTypes ? Adapter : ExtractUnionAdapter<Adapter, {
        method: MethodType;
        options: AdapterOptions;
        queryParams: TypeWithDefaults<RequestProperties, "queryParams", ExtractAdapterDefaultQueryParamsType<Adapter>, never>;
    }>>, false, false, false>;
}

type ClientErrorType = Record<string, any> | string;
type ClientInstanceProperties = {
    error?: any;
    adapter?: AdapterInstance;
};
type ClientInstance<ClientProperties extends ClientInstanceProperties = {
    error?: any;
    adapter?: AdapterInstance;
}> = Client$1<TypeWithDefaults<ClientProperties, "error", any>, TypeWithDefaults<ClientProperties, "adapter", AdapterInstance>>;
type RequestGenericType<QueryParams> = {
    response?: any;
    payload?: any;
    error?: any;
    queryParams?: QueryParams;
    endpoint?: string;
    params?: Record<string, string | number>;
};
/**
 * Configuration setup for the client
 */
type ClientOptionsType<C extends ClientInstance> = {
    /**
     * Url to your server
     */
    url: string;
    /**
     * Custom cache initialization prop
     */
    cache?: () => C["cache"];
    /**
     * Custom app manager initialization prop
     */
    appManager?: () => C["appManager"];
    /**
     * Custom fetch dispatcher initialization prop
     */
    fetchDispatcher?: () => C["submitDispatcher"];
    /**
     * Custom submit dispatcher initialization prop
     */
    submitDispatcher?: () => C["fetchDispatcher"];
};
type RequestInterceptorType = (request: RequestInstance) => Promise<RequestInstance> | RequestInstance;
type ResponseInterceptorType<Client extends ClientInstance, Response = any, Error = any> = (response: ResponseType<Response, Error, ExtractClientAdapterType<Client>>, request: ExtendRequest<RequestInstance, {
    client: Client;
}>) => Promise<ResponseType<any, any, ExtractClientAdapterType<Client>>> | ResponseType<any, any, ExtractClientAdapterType<Client>>;
type ModifyQueryParamsCallbackType<QueryParams, ModifiedQueryParams> = (queryParams: QueryParams) => ModifiedQueryParams;

declare const interceptRequest: (interceptors: RequestInterceptorType[], request: RequestInstance) => Promise<RequestInstance>;
declare const interceptResponse: <GlobalErrorType, Client extends ClientInstance>(interceptors: ResponseInterceptorType<Client>[], response: ResponseType<any, GlobalErrorType, ExtractClientAdapterType<Client>>, request: ExtendRequest<RequestInstance, {
    client: Client;
}>) => Promise<ResponseType<any, GlobalErrorType, ExtractClientAdapterType<Client>>>;

declare const stringifyDefaultOptions: {
    readonly strict: true;
    readonly encode: true;
    readonly arrayFormat: "bracket";
    readonly arraySeparator: "bracket";
    readonly sort: false;
    readonly skipNull: true;
    readonly skipEmptyString: true;
};

type ClientGenericType = {
    error?: ClientErrorType;
};
declare function createClient<ClientProperties extends ClientGenericType = {}>(options: ClientOptionsType<Client$1<NonNullable<TypeWithDefaults<ClientProperties, "error", Error>>>>): Client$1<NonNullable<TypeWithDefaults<ClientProperties, "error", Error>>, HttpAdapterType>;

declare class Plugin<Client extends ClientInstance = ClientInstance, PluginData = void> {
    config: PluginOptionsType<PluginData>;
    name: string;
    data: PluginData;
    client: Client | undefined;
    private pluginMethods;
    constructor(config: PluginOptionsType<PluginData>);
    initialize: (client: Client) => this;
    trigger: <Key extends keyof PluginMethods<Client>>(method: Key, data: PluginMethodParameters<Key, Client>) => void;
    /**
     * Callback that will be executed when plugin is mounted
     */
    onMount: (callback: PluginMethods<Client>["onMount"]) => this;
    /**
     * Callback that will be executed when plugin is unmounted
     */
    onUnmount: (callback: PluginMethods<Client>["onUnmount"]) => this;
    /**
     * Callback that will be executed when request is created
     */
    onRequestCreate: (callback: PluginMethods<Client>["onRequestCreate"]) => this;
    /**
     * Callback that will be executed when request gets triggered
     */
    onRequestTrigger: (callback: PluginMethods<Client>["onRequestTrigger"]) => this;
    /**
     * Callback that will be executed when request starts
     */
    onRequestStart: (callback: PluginMethods<Client>["onRequestStart"]) => this;
    /**
     * Callback that will be executed when response is successful
     */
    onRequestSuccess: (callback: PluginMethods<Client>["onRequestSuccess"]) => this;
    /**
     * Callback that will be executed when response is failed
     */
    onRequestError: (callback: PluginMethods<Client>["onRequestError"]) => this;
    /**
     * Callback that will be executed when response is finished
     */
    onRequestFinished: (callback: PluginMethods<Client>["onRequestFinished"]) => this;
    onDispatcherCleared: (callback: PluginMethods<Client>["onDispatcherCleared"]) => this;
    onDispatcherQueueDrained: (callback: PluginMethods<Client>["onDispatcherQueueDrained"]) => this;
    onDispatcherQueueRunning: (callback: PluginMethods<Client>["onDispatcherQueueRunning"]) => this;
    onDispatcherItemAdded: (callback: PluginMethods<Client>["onDispatcherItemAdded"]) => this;
    onDispatcherItemDeleted: (callback: PluginMethods<Client>["onDispatcherItemDeleted"]) => this;
    onDispatcherQueueCreated: (callback: PluginMethods<Client>["onDispatcherQueueCreated"]) => this;
    onDispatcherQueueCleared: (callback: PluginMethods<Client>["onDispatcherQueueCleared"]) => this;
    onCacheItemChange: (callback: PluginMethods<Client>["onCacheItemChange"]) => this;
    onCacheItemDelete: (callback: PluginMethods<Client>["onCacheItemDelete"]) => this;
    onAdapterFetch: (callback: PluginMethods<Client>["onAdapterFetch"]) => this;
}

type PluginLifecycle = "trigger" | "start" | "success" | "error" | "finished";
type PluginInstance = Plugin<any, any>;
type PluginRequest<C extends ClientInstance> = ExtendRequest<RequestInstance, {
    client: C;
}>;
type PluginOptionsType<PluginData> = {
    /**
     * Name of the plugin
     */
    name: string;
    /**
     * Data stored in a plugin
     */
    data?: PluginData;
};
type PluginMethods<Client extends ClientInstance> = {
    onMount?: (data: {
        client: Client;
    }) => void;
    onUnmount?: (data: {
        client: Client;
    }) => void;
    onRequestCreate?: (data: {
        request: PluginRequest<Client>;
    }) => void;
    onRequestTrigger?: (data: {
        request: PluginRequest<Client>;
    }) => void;
    onRequestStart?: (data: {
        request: PluginRequest<Client>;
    }) => void;
    onRequestSuccess?: (data: {
        response: ResponseSuccessType<ExtractResponseType<PluginRequest<Client>>, ExtractAdapterType<PluginRequest<Client>>>;
        request: PluginRequest<Client>;
    }) => void;
    onRequestError?: (data: {
        response: ResponseErrorType<ExtractErrorType<PluginRequest<Client>>, ExtractAdapterType<PluginRequest<Client>>>;
        request: PluginRequest<Client>;
    }) => void;
    onRequestFinished?: (data: {
        response: ResponseType<ExtractResponseType<PluginRequest<Client>>, ExtractErrorType<PluginRequest<Client>>, ExtractAdapterType<PluginRequest<Client>>>;
        request: PluginRequest<Client>;
    }) => void;
    onCacheItemChange?: <Requests extends {
        cacheKey: string;
        response: any;
        error: any;
    }>(data: {
        cache: Cache<ExtractClientAdapterType<Client>>;
        cacheKey: Requests["cacheKey"];
        prevData: CacheValueType<Requests["response"], Requests["error"], ExtractClientAdapterType<Client>> | null;
        newData: CacheValueType<Requests["response"], Requests["error"], ExtractClientAdapterType<Client>>;
    }) => void;
    onCacheItemDelete?: (data: {
        cacheKey: string;
        cache: Cache<ExtractClientAdapterType<Client>>;
    }) => void;
    onCacheItemInvalidate?: (data: {
        cacheKey: string;
        cache: Cache<ExtractClientAdapterType<Client>>;
    }) => void;
    onDispatcherCleared?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
    }) => void;
    onDispatcherQueueDrained?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
        queue: QueueDataType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
    }) => void;
    onDispatcherItemAdded?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
        queue: QueueDataType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
        queueItem: QueueItemType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
    }) => void;
    onDispatcherItemDeleted?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
        queue: QueueDataType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
        queueItem: QueueItemType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
    }) => void;
    onDispatcherQueueRunning?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
        queue: QueueDataType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
        status: "paused" | "stopped" | "running";
    }) => void;
    onDispatcherQueueCreated?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
        queue: QueueDataType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
    }) => void;
    onDispatcherQueueCleared?: (data: {
        dispatcher: Dispatcher<ExtractClientAdapterType<Client>>;
        queue: QueueDataType<ExtendRequest<RequestInstance, {
            client: Client;
        }>>;
    }) => void;
    onAdapterFetch?: (data: {
        request: RequestInstance;
        requestId: string;
        adapter: AdapterInstance;
    }) => void;
};
type PluginMethodParameters<Key extends keyof PluginMethods<Client>, Client extends ClientInstance> = Parameters<NonNullable<PluginMethods<Client>[Key]>>[0];

type RecursiveSchemaType = Record<string, // for example users / $userId / posts / $postId
any>;
type CreateSdkOptions = {
    /** @default true */
    camelCaseToKebabCase?: boolean;
    /** @default (method) => method.toUpperCase() */
    methodTransform?: (method: string) => string;
};
declare const createSdk: <Client extends ClientInstance, RecursiveSchema extends RecursiveSchemaType>(client: Client, options?: CreateSdkOptions) => RecursiveSchema;

declare enum Time {
    SEC = 1000,
    MIN = 60000,
    HOUR = 3600000,
    DAY = 86400000,
    WEEK = 604800000,
    MONTH_30 = 2592000000,
    MONTH_31 = 2678400000,
    YEAR = 31536000000,
    YEAR_LEAP = 31622400000
}

declare enum HttpMethods {
    GET = "GET",
    POST = "POST",
    PUT = "PUT",
    PATCH = "PATCH",
    DELETE = "DELETE"
}

export { AbortError, Adapter, type AdapterFetcherType, type AdapterGenericType, type AdapterInstance, type AdapterPayloadMappingType, AppEvents, AppManager, type AppManagerOptionsType, type BufferEncoding, Cache, type CacheAsyncStorageType, type CacheInitialData, type CacheOptionsType, type CacheSetState, type CacheStorageType, type CacheValueType, Client$1 as Client, type ClientErrorType, type ClientGenericType, type ClientInstance, type ClientInstanceProperties, type ClientOptionsType, type CreateSdkOptions, type DeclareAdapterType, type DefaultEndpointMapper, type DefaultHeaderMapper, type DefaultMapperType, type DefaultPayloadMapper, type DefaultQueryParamsMapper, DeletedError, Dispatcher, DispatcherMode, type DispatcherOptionsType, type DispatcherStorageType, type EmptyTypes, type EndpointMapper, EventEmitter, type ExtendRequest, type ExtractAdapterDefaultQueryParamsType, type ExtractAdapterEndpointMapperType, type ExtractAdapterEndpointType, type ExtractAdapterExtraType, type ExtractAdapterHeaderMapperType, type ExtractAdapterMethodType, type ExtractAdapterOptionsType, type ExtractAdapterPayloadMapperType, type ExtractAdapterQueryParamsMapperType, type ExtractAdapterQueryParamsType, type ExtractAdapterResolvedType, type ExtractAdapterStatusType, type ExtractAdapterType, type ExtractClientAdapterType, type ExtractClientGlobalError, type ExtractClientType, type ExtractEndpointType, type ExtractErrorType, type ExtractGlobalErrorType, type ExtractHasParamsType, type ExtractHasPayloadType, type ExtractHasQueryParamsType, type ExtractLocalErrorType, type ExtractParamsType, type ExtractPayloadType, type ExtractQueryParamsType, type ExtractResponseType, type ExtractUnionAdapter, type ExtractUrlParams, type FetchParamsType, type FetchPayloadType, type FetchQueryParamsType, type HeaderMappingType, HttpAdapter, type HttpAdapterExtraType, type HttpAdapterHeadersProps, type HttpAdapterOptionsType, type HttpAdapterRequest, type HttpAdapterType, HttpMethods, type HttpMethodsType, type HttpStatusType, type HydrateDataType, type HydrationOptions, type LogData, type LogDataTypes, type LogLevel, type LogRequestEventType, type LogResponseEventType, type LogSystemEventType, type LoggerArgs, LoggerManager, type LoggerMethods, type LoggerOptionsType, type LoggerType, type MockResponseType, type MockerConfigType, type ModifyQueryParamsCallbackType, type NonNullableKeys, type NullableKeys, type NullableType, type ParamType, type ParamsType, type PayloadMapperType, type PayloadType, Plugin, type PluginInstance, type PluginLifecycle, type PluginMethodParameters, type PluginMethods, type PluginOptionsType, type PluginRequest, type Prettify, type ProgressDataType, type ProgressEventType, type ProgressType, type QueryParamType, type QueryParamValuesType, type QueryParamsMapper, type QueryParamsType, type QueryStringifyOptionsType, type QueueDataType, type QueueItemType, type RecursiveSchemaType, Request, type RequestCacheType, type RequestConfigurationType, type RequestDeduplicatedEventType, type RequestDynamicSendOptionsType, type RequestEventType, type RequestGenericType, type RequestInstance, type RequestInstanceProperties, type RequestInterceptorType, type RequestJSON, type RequestLoadingEventType, RequestManager, type RequestMapper, type RequestOptionsType, RequestProcessingError, type RequestProgressEventType, type RequestRemovedEventType, type RequestResponseEventType, type RequestResponseType, type RequestSendActionsType, type RequestSendOptionsType, type RequestSendType, type RequiredKeys, type ResponseDetailsType, type ResponseErrorType, type ResponseInterceptorType, type ResponseMapper, type ResponseSuccessType, type ResponseType, type RunningRequestValueType, type SyncOrAsync, Time, TimeoutError, type TypeWithDefaults, UnexpectedError, appManagerInitialOptions, canRetryRequest, createClient, createSdk, defaultMapper, defaultTimeout, getAbortByAbortKey, getAbortByIdKey, getAbortKey, getAdapterBindings, getAdapterHeaders, getAdapterOnError, getAdapterPayload, getAppManagerEvents, getCacheByKey, getCacheData, getCacheEvents, getCacheKey, getDeleteByKey, getDeleteKey, getDispatcherChangeByKey, getDispatcherChangeKey, getDispatcherDrainedByKey, getDispatcherDrainedKey, getDispatcherEvents, getDispatcherStatusByKey, getDispatcherStatusKey, getDownloadProgressByIdKey, getDownloadProgressByQueryKey, getDownloadProgressKey, getErrorMessage, getInvalidateByKey, getInvalidateKey, getIsEqualTimestamp, getLoadingByCacheKey, getLoadingByIdKey, getLoadingByQueryKey, getLoadingKey, getProgressData, getProgressValue, getRemoveByIdKey, getRemoveByQueryKey, getRemoveKey, getRequestDeduplicatedByCacheKey, getRequestDeduplicatedByIdKey, getRequestDeduplicatedByQueryKey, getRequestDeduplicatedKey, getRequestDispatcher, getRequestEta, getRequestKey, getRequestManagerEvents, getRequestStarByQueryKey, getRequestStartByIdKey, getRequestStartKey, getRequestType, getResponseByCacheKey, getResponseByIdKey, getResponseHeaders, getResponseKey, getResponseStartByIdKey, getResponseStartByQueryKey, getResponseStartKey, getSimpleKey, getTime, getUniqueRequestId, getUploadProgressByIdKey, getUploadProgressByQueryKey, getUploadProgressKey, handleResponse, hasDocument, hasWindow, interceptRequest, interceptResponse, logLevelOrder, logger, loggerColors, loggerStyles, mocker, onDocumentEvent, onWindowEvent, parseErrorResponse, parseResponse, sendRequest, stringifyDefaultOptions, stringifyKey, stringifyQueryParams, stringifyValue, xhrExtra };