@ventlio/tanstack-query 0.1.2 → 0.1.4

package/dist/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './scrollToTop';

package/dist/helpers/scrollToTop.d.ts

@@ -0,0 +1 @@
+export declare const scrollToTop: () => void;

package/dist/helpers/scrollToTop.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const scrollToTop = () => {
+    window.scrollTo({
+        top: 0,
+        behavior: 'smooth',
+    });
+};
+
+exports.scrollToTop = scrollToTop;
+//# sourceMappingURL=scrollToTop.js.map

package/dist/helpers/scrollToTop.js.map

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

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './constants';
+export * from './helpers';
+export * from './queries';
 export * from './request';
-export * from './useMyHook';

package/dist/index.js

@@ -1,16 +1,25 @@
 'use strict';
 
 var index = require('./constants/index.js');
+var scrollToTop = require('./helpers/scrollToTop.js');
+var useDeleteRequest = require('./queries/useDeleteRequest.js');
+var useGetRequest = require('./queries/useGetRequest.js');
+var usePatchRequest = require('./queries/usePatchRequest.js');
+var usePostRequest = require('./queries/usePostRequest.js');
 var axiosInstance = require('./request/axios-instance.js');
 var buildFormData = require('./request/buildFormData.js');
 var makeRequest = require('./request/make-request.js');
 var request_enum = require('./request/request.enum.js');
 var transformer = require('./request/transformer.js');
-var useMyHook = require('./useMyHook.js');
 
 
 
 exports.API_BASE_URL = index.API_BASE_URL;
+exports.scrollToTop = scrollToTop.scrollToTop;
+exports.useDeleteRequest = useDeleteRequest.useDeleteRequest;
+exports.useGetRequest = useGetRequest.useGetRequest;
+exports.usePatchRequest = usePatchRequest.usePatchRequest;
+exports.usePostRequest = usePostRequest.usePostRequest;
 exports.axiosInstance = axiosInstance.axiosInstance;
 exports.buildFormData = buildFormData.buildFormData;
 exports.makeRequest = makeRequest.makeRequest;
@@ -24,5 +33,4 @@ Object.defineProperty(exports, 'HttpMethod', {
 });
 exports.errorTransformer = transformer.errorTransformer;
 exports.successTransformer = transformer.successTransformer;
-exports.useMyHook = useMyHook.useMyHook;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/index.mjs

@@ -1,8 +1,16 @@
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { useState, startTransition } from 'react';
 import axios from 'axios';
-import { useState } from 'react';
 
 const API_BASE_URL = '';
 
+const scrollToTop = () => {
+    window.scrollTo({
+        top: 0,
+        behavior: 'smooth',
+    });
+};
+
 const axiosInstance = (headers) => {
     return axios.create({
         baseURL: 'https://api.ventlio.com',
@@ -18,7 +26,7 @@ const buildFormData = (body) => {
         formData.append(key, body[key]);
     });
     body = formData;
-    return { body };
+    return body;
 };
 
 var HttpMethod;
@@ -56,25 +64,23 @@ const successTransformer = (data) => {
     };
 };
 
-async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, formData, }) {
-    // construct api full url
-    const apiFullUrl = `${API_BASE_URL}${path}`;
+async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, isFormData, }) {
     // configure body
-    body = formData ? buildFormData(body) : body;
+    body = isFormData ? buildFormData(body) : body;
     // configure request header
     const headers = {
         Authorization: `Bearer ${bearerToken}`,
     };
-    if (!formData) {
+    if (!isFormData) {
         headers['Content-Type'] = ContentType.APPLICATION_JSON;
     }
     try {
         const axios = axiosInstance(headers);
         //   send request
         const resp = await axios({
-            url: apiFullUrl,
+            url: path,
             method,
-            data: formData ? body : JSON.stringify(body),
+            data: body,
         });
         // get response json
         const jsonResp = await resp.data();
@@ -98,13 +104,207 @@ async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, f
     }
 }
 
-const useMyHook = () => {
-    const [value, setValue] = useState('');
-    const updateValue = (newValue) => {
-        setValue(newValue);
+const useDeleteRequest = () => {
+    const [requestPath, updateDeletePath] = useState('');
+    const [options, setOptions] = useState();
+    const authToken = '';
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        setTimeout(async () => {
+            const postResponse = await makeRequest({
+                path: requestPath,
+                bearerToken: authToken,
+                method: HttpMethod.DELETE,
+            });
+            if (postResponse.status) {
+                res(postResponse);
+            }
+            else {
+                rej(postResponse);
+            }
+        }, 200);
+    }), { ...options });
+    const updatedPathAsync = async (link) => {
+        return updateDeletePath(link);
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        return setOptions(fetchOptions);
+    };
+    const deleteR = async (link, fetchOptions) => {
+        await updatedPathAsync(link);
+        await setOptionsAsync(fetchOptions);
+        return query.refetch({
+            queryKey: [link, {}],
+        });
+    };
+    return { updateDeletePath, deleteR, ...query };
+};
+
+const useGetRequest = ({ path, load = false, queryOptions, }) => {
+    const [requestPath, updatePath] = useState(path);
+    const authToken = '';
+    const [options, setOptions] = useState(queryOptions);
+    const [page, setPage] = useState(1);
+    const sendRequest = async (res, rej) => {
+        const postResponse = await makeRequest({
+            path: requestPath,
+            bearerToken: authToken,
+        });
+        if (postResponse.status) {
+            res(postResponse);
+        }
+        else {
+            rej(postResponse);
+        }
+    };
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        return sendRequest(res, rej);
+    }), {
+        enabled: load,
+        ...options,
+    });
+    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) {
+                updatePath(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) {
+                updatePath(constructPaginationLink(requestPath, pagination.previous_page));
+            }
+        }
+    };
+    const constructPaginationLink = (link, pageNumber) => {
+        const oldLink = link;
+        if (link.includes('?')) {
+            if (link.includes('?page=')) {
+                // replace current page number with new number
+                link = link.replace(/\?page=(\d+)/gim, `?page=${pageNumber}`);
+            }
+            else if (link.includes('&page=')) {
+                link = link.replace(/&page=(\d+)/gim, `&page=${pageNumber}`);
+            }
+            else {
+                link = `${link}&page=${pageNumber}`;
+            }
+        }
+        else {
+            link = `${link}?page=${pageNumber}`;
+        }
+        // only update page when pagination is done
+        if (oldLink !== link) {
+            setPage(pageNumber);
+        }
+        return link;
+    };
+    const gotoPage = (pageNumber) => {
+        updatePath(constructPaginationLink(requestPath, pageNumber));
+    };
+    const updatedPathAsync = async (link) => {
+        startTransition(() => {
+            updatePath(link);
+        });
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        await setOptionsAsync(fetchOptions);
+        await updatedPathAsync(link);
+        return query.data;
+    };
+    return {
+        ...query,
+        updatePath,
+        nextPage,
+        prevPage,
+        get,
+        gotoPage,
+        page,
+        queryKey: [requestPath, {}],
+    };
+};
+
+const usePatchRequest = ({ path, isFormData = false, }) => {
+    const authToken = '';
+    const [resetForm, setResetForm] = useState(false);
+    // register post mutation
+    const mutation = useMutation((postData) => new Promise((res, rej) => {
+        setResetForm(false);
+        makeRequest({
+            path: path,
+            body: postData,
+            method: HttpMethod.PATCH,
+            bearerToken: authToken,
+            isFormData,
+        }).then((postResponse) => {
+            if (postResponse.status) {
+                setResetForm(true);
+                // scroll to top after success
+                scrollToTop();
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                rej(postResponse);
+            }
+        });
+    }));
+    const patch = async (postData, options) => {
+        return mutation.mutateAsync(postData, options);
+    };
+    return { patch, ...mutation, resetForm };
+};
+
+const usePostRequest = ({ path, isFormData = false, }) => {
+    const authToken = '';
+    const [resetForm, setResetForm] = useState(false);
+    // register post mutation
+    const mutation = useMutation(async (postData) => new Promise((res, rej) => {
+        setResetForm(false);
+        makeRequest({
+            path: path,
+            body: postData,
+            method: HttpMethod.POST,
+            bearerToken: authToken,
+            isFormData,
+        }).then((postResponse) => {
+            if (postResponse.status) {
+                setResetForm(true);
+                // scroll to top after success
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                rej(postResponse);
+            }
+        });
+    }));
+    const post = async (postData, options) => {
+        return mutation.mutateAsync(postData, options);
     };
-    return [value, updateValue];
+    return { post, ...mutation, resetForm };
 };
 
-export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, successTransformer, useMyHook };
+export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useGetRequest, usePatchRequest, usePostRequest };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/dist/queries/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useDeleteRequest';
+export * from './useGetRequest';
+export * from './usePatchRequest';
+export * from './usePostRequest';

package/dist/queries/queries.interface.d.ts

@@ -0,0 +1,11 @@
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+export interface IPagination {
+    current_page: number;
+    next_page: number;
+    page_count: number;
+    previous_page: number;
+    size: number;
+    total: number;
+}
+export type TanstackQueryOption<TResponse> = UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>;

package/dist/queries/useDeleteRequest.d.ts

@@ -0,0 +1,116 @@
+/// <reference types="react" />
+import type { MutateOptions, QueryObserverResult } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+export declare const useDeleteRequest: <TResponse>() => {
+    data: IRequestSuccess<TResponse>;
+    error: any;
+    isError: true;
+    isLoading: 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;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+} | {
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    isError: false;
+    isLoading: 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;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+} | {
+    data: undefined;
+    error: any;
+    isError: true;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    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;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+};

package/dist/queries/useDeleteRequest.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var react = require('react');
+require('axios');
+var makeRequest = require('../request/make-request.js');
+var request_enum = require('../request/request.enum.js');
+
+const useDeleteRequest = () => {
+    const [requestPath, updateDeletePath] = react.useState('');
+    const [options, setOptions] = react.useState();
+    const authToken = '';
+    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        setTimeout(async () => {
+            const postResponse = await makeRequest.makeRequest({
+                path: requestPath,
+                bearerToken: authToken,
+                method: request_enum.HttpMethod.DELETE,
+            });
+            if (postResponse.status) {
+                res(postResponse);
+            }
+            else {
+                rej(postResponse);
+            }
+        }, 200);
+    }), { ...options });
+    const updatedPathAsync = async (link) => {
+        return updateDeletePath(link);
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        return setOptions(fetchOptions);
+    };
+    const deleteR = async (link, fetchOptions) => {
+        await updatedPathAsync(link);
+        await setOptionsAsync(fetchOptions);
+        return query.refetch({
+            queryKey: [link, {}],
+        });
+    };
+    return { updateDeletePath, deleteR, ...query };
+};
+
+exports.useDeleteRequest = useDeleteRequest;
+//# sourceMappingURL=useDeleteRequest.js.map

package/dist/queries/useDeleteRequest.js.map

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

package/dist/queries/useGetRequest.d.ts

@@ -0,0 +1,141 @@
+/// <reference types="react" />
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+import type { TanstackQueryOption } from './queries.interface';
+export declare const useGetRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, }: {
+    path: string;
+    load?: boolean | undefined;
+    queryOptions?: TanstackQueryOption<TResponse> | undefined;
+}) => {
+    updatePath: 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;
+    isLoading: 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;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    updatePath: 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;
+    isLoading: 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;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    updatePath: 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: undefined;
+    error: any;
+    isError: true;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    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;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    updatePath: 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: undefined;
+    error: null;
+    isError: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};