@ventlio/tanstack-query 0.5.4 → 0.5.6

package/dist/queries/useGetRequest.d.ts

@@ -1,74 +1,73 @@
-/// <reference types="react" />
-import type { UseQueryOptions } from '@tanstack/react-query';
-import type { IRequestError, IRequestSuccess } from '../request';
-import type { DefaultRequestOptions, TanstackQueryOption } from './queries.interface';
-export declare const useGetRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, keyTracker, baseUrl, headers, }: {
-    path: string;
-    load?: boolean | undefined;
-    queryOptions?: TanstackQueryOption<TResponse> | undefined;
-    keyTracker?: string | undefined;
-} & DefaultRequestOptions) => {
-    isLoading: boolean;
-    setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    nextPage: () => void;
-    prevPage: () => void;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    gotoPage: (pageNumber: number) => void;
-    page: number;
-    queryKey: {}[];
-    data: IRequestSuccess<TResponse>;
-    error: any;
-    isError: true;
-    isPending: false;
-    isLoadingError: false;
-    isRefetchError: true;
-    isSuccess: false;
-    status: "error";
-    dataUpdatedAt: number;
-    errorUpdatedAt: number;
-    failureCount: number;
-    failureReason: any;
-    errorUpdateCount: number;
-    isFetched: boolean;
-    isFetchedAfterMount: boolean;
-    isFetching: boolean;
-    isInitialLoading: boolean;
-    isPaused: boolean;
-    isPlaceholderData: boolean;
-    isRefetching: boolean;
-    isStale: boolean;
-    refetch: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ac | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").as<IRequestSuccess<TResponse>, any>>;
-    fetchStatus: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ak;
-} | {
-    isLoading: boolean;
-    setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    nextPage: () => void;
-    prevPage: () => void;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    gotoPage: (pageNumber: number) => void;
-    page: number;
-    queryKey: {}[];
-    data: IRequestSuccess<TResponse>;
-    error: null;
-    isError: false;
-    isPending: false;
-    isLoadingError: false;
-    isRefetchError: false;
-    isSuccess: true;
-    status: "success";
-    dataUpdatedAt: number;
-    errorUpdatedAt: number;
-    failureCount: number;
-    failureReason: any;
-    errorUpdateCount: number;
-    isFetched: boolean;
-    isFetchedAfterMount: boolean;
-    isFetching: boolean;
-    isInitialLoading: boolean;
-    isPaused: boolean;
-    isPlaceholderData: boolean;
-    isRefetching: boolean;
-    isStale: boolean;
-    refetch: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ac | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").as<IRequestSuccess<TResponse>, any>>;
-    fetchStatus: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ak;
-};
+import { UseQueryOptions } from '@tanstack/react-query';
+import { IRequestError, IRequestSuccess } from '../request';
+import { DefaultRequestOptions, TanstackQueryOption } from './queries.interface';
+export declare const useGetRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, keyTracker, baseUrl, headers, }: {
+    path: string;
+    load?: boolean;
+    queryOptions?: TanstackQueryOption<TResponse>;
+    keyTracker?: string;
+} & DefaultRequestOptions) => {
+    isLoading: boolean;
+    setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    nextPage: () => void;
+    prevPage: () => void;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>) => Promise<IRequestSuccess<TResponse> | undefined>;
+    gotoPage: (pageNumber: number) => void;
+    page: number;
+    queryKey: {}[];
+    data: IRequestSuccess<TResponse>;
+    error: any;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    isLoading: boolean;
+    setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    nextPage: () => void;
+    prevPage: () => void;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>) => Promise<IRequestSuccess<TResponse> | undefined>;
+    gotoPage: (pageNumber: number) => void;
+    page: number;
+    queryKey: {}[];
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/queries/useGetRequest.js

@@ -9,139 +9,135 @@ import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
 
-const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const [requestPath, setRequestPath] = useState(path);
-    const [options, setOptions] = useState(queryOptions);
-    const [page, setPage] = useState(1);
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const { options: queryConfigOptions } = useQueryConfig();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
-    let queryClient = useQueryClient();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    queryClient = useMemo(() => queryClient, []);
-    const sendRequest = async (res, rej, queryKey) => {
-        if (load) {
-            const [url] = queryKey;
-            const requestUrl = (url ?? requestPath);
-            const requestOptions = {
-                path: requestUrl,
-                headers: { ...globalHeaders, ...headers },
-                baseURL: baseUrl ?? API_URL,
-                timeout: TIMEOUT,
-            };
-            let shouldContinue = true;
-            if (queryConfigOptions?.queryMiddleware) {
-                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
-            }
-            if (shouldContinue) {
-                const getResponse = await makeRequest(requestOptions);
-                if (getResponse.status) {
-                    res(getResponse);
-                }
-                else {
-                    rej(getResponse);
-                }
-            }
-            else {
-                rej(null);
-            }
-        }
-        else {
-            res(null);
-        }
-    };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
-        enabled: load && !isFutureQueriesPaused,
-        ...options,
-    });
-    useEffect(() => {
-        if (path) {
-            setRequestPath(path);
-        }
-    }, [path]);
-    useEffect(() => {
-        if (keyTracker) {
-            // set expiration time for the tracker
-            queryClient.setQueryDefaults([keyTracker], {
-                staleTime: Infinity,
-            });
-            queryClient.setQueryData([keyTracker], [requestPath, {}]);
-        }
-    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
-    const nextPage = () => {
-        if (query.data?.data.pagination) {
-            const pagination = query.data.data.pagination;
-            if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
-                setRequestPath(constructPaginationLink(requestPath, pagination.next_page));
-            }
-        }
-    };
-    const prevPage = () => {
-        if (query.data?.data.pagination) {
-            const pagination = query.data.data.pagination;
-            if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
-                setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
-            }
-        }
-    };
-    const constructPaginationLink = (link, pageNumber) => {
-        const [pathname, queryString] = link.split('?');
-        const queryParams = new URLSearchParams(queryString);
-        const oldPage = Number(queryParams.get('page'));
-        queryParams.set('page', pageNumber);
-        link = pathname + '?' + queryParams.toString();
-        // only update page when pagination number changed
-        if (oldPage !== pageNumber) {
-            setPage(pageNumber);
-        }
-        return link;
-    };
-    const gotoPage = (pageNumber) => {
-        setRequestPath(constructPaginationLink(requestPath, pageNumber));
-    };
-    const updatedPathAsync = async (link) => {
-        startTransition(() => {
-            setRequestPath(link);
-        });
-    };
-    const setOptionsAsync = async (fetchOptions) => {
-        startTransition(() => {
-            setOptions(fetchOptions);
-        });
-    };
-    const get = async (link, fetchOptions) => {
-        if (!isFutureQueriesPaused) {
-            await setOptionsAsync(fetchOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setRequestPayload({ link, fetchOptions });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureQueriesPaused && requestPayload) {
-            get(requestPayload.link, requestPayload.fetchOptions);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureQueriesPaused]);
-    return {
-        ...query,
-        isLoading: query.isLoading || isFutureQueriesPaused,
-        setRequestPath,
-        nextPage,
-        prevPage,
-        get,
-        gotoPage,
-        page,
-        queryKey: [requestPath, {}],
-    };
+const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
+    const [requestPath, setRequestPath] = useState(path);
+    const [options, setOptions] = useState(queryOptions);
+    const [page, setPage] = useState(1);
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
+    let queryClient = useQueryClient();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    queryClient = useMemo(() => queryClient, []);
+    const sendRequest = async (res, rej, queryKey) => {
+        const [url] = queryKey;
+        const requestUrl = (url ?? requestPath);
+        const requestOptions = {
+            path: requestUrl,
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            timeout: TIMEOUT,
+        };
+        let getResponse;
+        if (queryConfigOptions?.middleware) {
+            // perform global middleware
+            getResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                path,
+                baseUrl: baseUrl ?? API_URL,
+            });
+        }
+        else {
+            getResponse = await makeRequest(requestOptions);
+        }
+        if (getResponse.status) {
+            res(getResponse);
+        }
+        else {
+            rej(getResponse);
+        }
+    };
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+        enabled: load && !isFutureQueriesPaused,
+        ...options,
+    });
+    useEffect(() => {
+        if (path) {
+            setRequestPath(path);
+        }
+    }, [path]);
+    useEffect(() => {
+        if (keyTracker) {
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
+        }
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
+    const nextPage = () => {
+        if (query.data.data.pagination) {
+            const pagination = query.data.data.pagination;
+            if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
+                setRequestPath(constructPaginationLink(requestPath, pagination.next_page));
+            }
+        }
+    };
+    const prevPage = () => {
+        if (query.data.data.pagination) {
+            const pagination = query.data.data.pagination;
+            if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
+                setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
+            }
+        }
+    };
+    const constructPaginationLink = (link, pageNumber) => {
+        const [pathname, queryString] = link.split('?');
+        const queryParams = new URLSearchParams(queryString);
+        const oldPage = Number(queryParams.get('page'));
+        queryParams.set('page', pageNumber);
+        link = pathname + '?' + queryParams.toString();
+        // only update page when pagination number changed
+        if (oldPage !== pageNumber) {
+            setPage(pageNumber);
+        }
+        return link;
+    };
+    const gotoPage = (pageNumber) => {
+        setRequestPath(constructPaginationLink(requestPath, pageNumber));
+    };
+    const updatedPathAsync = async (link) => {
+        startTransition(() => {
+            setRequestPath(link);
+        });
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        if (!isFutureQueriesPaused) {
+            await setOptionsAsync(fetchOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, fetchOptions });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
+    return {
+        ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
+        setRequestPath,
+        nextPage,
+        prevPage,
+        get,
+        gotoPage,
+        page,
+        queryKey: [requestPath, {}],
+    };
 };
 
 export { useGetRequest };

package/dist/queries/useGetRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/usePatchRequest.d.ts

@@ -1,86 +1,86 @@
-import type { MutateOptions } from '@tanstack/react-query';
-import type { IRequestError, IRequestSuccess } from '../request/request.interface';
-import type { DefaultRequestOptions } from './queries.interface';
-export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
-    path: string;
-} & DefaultRequestOptions) => {
-    isLoading: boolean;
-    data: undefined;
-    variables: undefined;
-    error: null;
-    isError: false;
-    isIdle: true;
-    isPending: false;
-    isSuccess: false;
-    status: "idle";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: undefined;
-    variables: void;
-    error: null;
-    isError: false;
-    isIdle: false;
-    isPending: true;
-    isSuccess: false;
-    status: "pending";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: undefined;
-    error: IRequestError;
-    variables: void;
-    isError: true;
-    isIdle: false;
-    isPending: false;
-    isSuccess: false;
-    status: "error";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: IRequestSuccess<TResponse>;
-    error: null;
-    variables: void;
-    isError: false;
-    isIdle: false;
-    isPending: false;
-    isSuccess: true;
-    status: "success";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-};
+import type { MutateOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request/request.interface';
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
+    path: string;
+} & DefaultRequestOptions) => {
+    isLoading: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    variables: void;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: IRequestError;
+    variables: void;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    variables: void;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+};