@ventlio/tanstack-query 0.2.5 → 0.2.7-2.1

package/dist/model/model.interface.d.ts

@@ -0,0 +1,11 @@
+export interface QueryModelBuilder<T> {
+    add: (data: T, position?: QueryModelAddPosition, path?: string) => T | undefined;
+    findAll: (path?: string) => T[] | T | undefined;
+    findMany: (selector: (record: T) => boolean, path?: string) => T[];
+    find: (id: number | string, path?: string) => T | undefined;
+    update: (id: number | string, data: Partial<T>, path?: string) => T | undefined;
+    remove: (id: number, path?: string) => boolean;
+    get: (path?: string) => T | undefined;
+    set: <DataType>(data: Partial<DataType>, path?: string) => DataType | undefined;
+}
+export type QueryModelAddPosition = 'start' | 'end';

package/dist/model/useKeyTrackerModel.d.ts

@@ -0,0 +1,4 @@
+export declare const useKeyTrackerModel: <T>(keyTracker: string) => {
+    refetchQuery: (innerKeyTracker?: string) => Promise<void>;
+    getQueryKey: (innerKeyTracker?: string) => any[] | undefined;
+};

package/dist/model/useKeyTrackerModel.js

@@ -0,0 +1,20 @@
+import { useQueryClient } from '@tanstack/react-query';
+
+const useKeyTrackerModel = (keyTracker) => {
+    const queryClient = useQueryClient();
+    const getQueryKey = (innerKeyTracker) => {
+        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
+        return queryKey;
+    };
+    const refetchQuery = async (innerKeyTracker) => {
+        const queryKey = getQueryKey(innerKeyTracker ?? keyTracker);
+        await queryClient.refetchQueries({
+            queryKey,
+            exact: true,
+        });
+    };
+    return { refetchQuery, getQueryKey };
+};
+
+export { useKeyTrackerModel };
+//# sourceMappingURL=useKeyTrackerModel.js.map

package/dist/model/useKeyTrackerModel.js.map

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

package/dist/model/useQueryModel.d.ts

@@ -0,0 +1,2 @@
+import type { QueryModelBuilder } from './model.interface';
+export declare const useQueryModel: <T>(keyTracker: string, exact?: boolean) => QueryModelBuilder<T>;

package/dist/model/useQueryModel.js

@@ -0,0 +1,123 @@
+import { useQueryClient } from '@tanstack/react-query';
+import result from 'lodash.result';
+import lodashSet from 'lodash.set';
+import { useKeyTrackerModel } from './useKeyTrackerModel.js';
+
+const useQueryModel = (keyTracker, exact = true) => {
+    const queryClient = useQueryClient();
+    const { getQueryKey } = useKeyTrackerModel(keyTracker);
+    const queryKey = getQueryKey();
+    const add = (data, position, path) => {
+        let records = (findAll(path) ?? []);
+        if (!position || position === 'end') {
+            records = [...records, data];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        }
+        else if (position === 'start') {
+            records = [data, ...records];
+        }
+        if (!path) {
+            queryClient.setQueryData(queryKey, records);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
+        }
+        return data;
+    };
+    const findAll = (path) => {
+        const data = queryClient.getQueryData(queryKey, { exact });
+        if (!data) {
+            return [];
+        }
+        if (!path) {
+            return Array.isArray(data) ? data : [data];
+        }
+        return result(data, path, []);
+    };
+    const findMany = (selector, path) => {
+        const data = (findAll(path) ?? []);
+        return data.filter(selector);
+    };
+    const find = (id, path) => {
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const data = (findAll(path) ?? []);
+        return data.find((record) => record[modelConfig.idColumn] === id);
+    };
+    const get = (path) => {
+        let data = queryClient.getQueryData(queryKey, { exact });
+        if (path) {
+            data = result(data, path);
+        }
+        return data;
+    };
+    const set = (newData, path) => {
+        if (path) {
+            const data = get();
+            newData = lodashSet(data, path, newData);
+        }
+        return queryClient.setQueryData(queryKey, newData);
+    };
+    const getModelConfig = () => {
+        const { options } = queryClient.getQueryData(['config']) ?? {};
+        const { modelConfig } = options ?? {};
+        return modelConfig;
+    };
+    const update = (id, data, path) => {
+        const oldData = (findAll(path) ?? []);
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updatedRecord = undefined;
+        const newData = oldData.map((record) => {
+            let dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                dataRecord = { ...dataRecord, ...data };
+                updatedRecord = dataRecord;
+            }
+            return dataRecord;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
+        }
+        return updatedRecord;
+    };
+    const remove = (id, path) => {
+        const oldData = (findAll(path) ?? []);
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return false;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updated = false;
+        const newData = oldData.filter((record) => {
+            const dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                updated = true;
+                return false;
+            }
+            return true;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
+        }
+        return updated;
+    };
+    return { find, findAll, findMany, remove, update, add, get, set };
+};
+
+export { useQueryModel };
+//# sourceMappingURL=useQueryModel.js.map

package/dist/model/useQueryModel.js.map

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

package/dist/model/useRefetchQuery.d.ts

@@ -0,0 +1,3 @@
+export declare const useRefetchQuery: (queryKey: any[]) => Promise<{
+    refetchQuery: <T>(innerQueryKey?: any[]) => Promise<[import("@tanstack/react-query").QueryKey, T | undefined][]>;
+}>;

package/dist/model/useRefetchQuery.js

@@ -0,0 +1,16 @@
+import { useQueryClient } from '@tanstack/react-query';
+
+const useRefetchQuery = async (queryKey) => {
+    const queryClient = useQueryClient();
+    const refetchQuery = async (innerQueryKey) => {
+        await queryClient.invalidateQueries({
+            queryKey: innerQueryKey ?? queryKey,
+            exact: true,
+        }, { throwOnError: true, cancelRefetch: true });
+        return queryClient.getQueriesData(innerQueryKey ?? queryKey);
+    };
+    return { refetchQuery };
+};
+
+export { useRefetchQuery };
+//# sourceMappingURL=useRefetchQuery.js.map

package/dist/model/useRefetchQuery.js.map

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

package/dist/queries/index.d.ts

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

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

@@ -1,4 +1,5 @@
 import type { UseQueryOptions } from '@tanstack/react-query';
+import type { RawAxiosRequestHeaders } from 'axios';
 import type { IRequestError, IRequestSuccess } from '../request';
 export interface IPagination {
     current_page: number;
@@ -9,3 +10,7 @@ export interface IPagination {
     total: number;
 }
 export type TanstackQueryOption<TResponse> = UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>;
+export interface DefaultRequestOptions {
+    baseUrl?: string;
+    headers?: RawAxiosRequestHeaders;
+}

package/dist/queries/useDeleteRequest.d.ts

@@ -1,6 +1,7 @@
 import type { UseQueryOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
-export declare const useDeleteRequest: <TResponse>() => {
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultRequestOptions) => {
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
@@ -26,7 +27,9 @@ export declare const useDeleteRequest: <TResponse>() => {
     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;
-    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: IRequestSuccess<TResponse>;
     error: null;
@@ -53,7 +56,9 @@ export declare const useDeleteRequest: <TResponse>() => {
     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;
-    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: undefined;
     error: any;
@@ -80,7 +85,9 @@ export declare const useDeleteRequest: <TResponse>() => {
     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;
-    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: undefined;
     error: null;
@@ -107,5 +114,7 @@ export declare const useDeleteRequest: <TResponse>() => {
     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;
-    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 };

package/dist/queries/useDeleteRequest.js

@@ -1,52 +1,52 @@
-'use strict';
+import { useQuery } from '@tanstack/react-query';
+import { useState } from 'react';
+import 'url-search-params-polyfill';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import 'axios';
+import { makeRequest } from '../request/make-request.js';
+import { HttpMethod } from '../request/request.enum.js';
 
-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');
-var useQueryConfig = require('./useQueryConfig.js');
-
-const useDeleteRequest = () => {
-    const [requestPath, updateDeletePath] = react.useState('');
-    const [options, setOptions] = react.useState();
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
-    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
-        setTimeout(async () => {
-            const postResponse = await makeRequest.makeRequest({
-                path: requestPath,
-                headers,
-                method: request_enum.HttpMethod.DELETE,
-                baseURL,
-                timeout,
-            });
-            if (postResponse.status) {
-                res(postResponse);
-            }
-            else {
-                rej(postResponse);
-            }
-        }, 200);
-    }), { ...options });
+const useDeleteRequest = (deleteOptions) => {
+    const { baseUrl, headers } = deleteOptions ?? {};
+    const [requestPath, updateDeletePath] = useState('');
+    const [options, setOptions] = useState();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { getHeaders } = useQueryHeaders();
+    const sendRequest = async (res, rej) => {
+        // get request headers
+        const globalHeaders = getHeaders();
+        const postResponse = await makeRequest({
+            path: requestPath,
+            headers: { ...globalHeaders, ...headers },
+            method: HttpMethod.DELETE,
+            baseURL: baseUrl ?? API_URL,
+            timeout: TIMEOUT,
+        });
+        if (postResponse.status) {
+            res(postResponse);
+        }
+        else {
+            rej(postResponse);
+        }
+    };
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), { enabled: false, ...options });
     const updatedPathAsync = async (link) => {
         return updateDeletePath(link);
     };
     const setOptionsAsync = async (fetchOptions) => {
         return setOptions(fetchOptions);
     };
-    const destroy = async (link, deleteOptions) => {
+    const destroy = async (link, internalDeleteOptions) => {
         // set enabled to be true for every delete
-        deleteOptions = deleteOptions ?? {};
-        deleteOptions.enabled = true;
+        internalDeleteOptions = internalDeleteOptions ?? {};
+        internalDeleteOptions.enabled = true;
+        await setOptionsAsync(internalDeleteOptions);
         await updatedPathAsync(link);
-        await setOptionsAsync(deleteOptions);
-        // return query.refetch<TResponse>({
-        //   queryKey: [link, {}],
-        // });
         return query.data;
     };
     return { destroy, ...query };
 };
 
-exports.useDeleteRequest = useDeleteRequest;
+export { useDeleteRequest };
 //# sourceMappingURL=useDeleteRequest.js.map

package/dist/queries/useGetRequest.d.ts

@@ -1,12 +1,13 @@
 /// <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, }: {
+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) => {
     updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;

package/dist/queries/useGetRequest.js

@@ -1,47 +1,65 @@
-'use strict';
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { useState, useMemo, useEffect, startTransition } from 'react';
+import 'url-search-params-polyfill';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import 'axios';
+import { makeRequest } from '../request/make-request.js';
+import '../request/request.enum.js';
 
-var reactQuery = require('@tanstack/react-query');
-var react = require('react');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-require('../request/request.enum.js');
-var useQueryConfig = require('./useQueryConfig.js');
-
-const useGetRequest = ({ path, load = false, queryOptions, }) => {
-    const [requestPath, updatePath] = react.useState(path);
-    const [options, setOptions] = react.useState(queryOptions);
-    const [page, setPage] = react.useState(1);
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
+const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
+    const [requestPath, updatePath] = useState(path);
+    const [options, setOptions] = useState(queryOptions);
+    const [page, setPage] = useState(1);
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { getHeaders } = useQueryHeaders();
+    let queryClient = useQueryClient();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    queryClient = useMemo(() => queryClient, []);
     const sendRequest = async (res, rej) => {
-        const postResponse = await makeRequest.makeRequest({
-            path: requestPath,
-            headers,
-            baseURL,
-            timeout,
-        });
-        if (postResponse.status) {
-            res(postResponse);
+        if (load) {
+            // get request headers
+            const globalHeaders = getHeaders();
+            const getResponse = await makeRequest({
+                path: requestPath,
+                headers: { ...globalHeaders, ...headers },
+                baseURL: baseUrl ?? API_URL,
+                timeout: TIMEOUT,
+            });
+            if (getResponse.status) {
+                res(getResponse);
+            }
+            else {
+                rej(getResponse);
+            }
         }
         else {
-            rej(postResponse);
+            res(null);
         }
     };
-    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
-        return sendRequest(res, rej);
-    }), {
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), {
         enabled: load,
         ...options,
     });
-    react.useEffect(() => {
+    useEffect(() => {
         if (path) {
             updatePath(path);
         }
     }, [path]);
+    useEffect(() => {
+        if (keyTracker) {
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
+                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) {
+            if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
                 updatePath(constructPaginationLink(requestPath, pagination.next_page));
             }
         }
@@ -49,17 +67,15 @@ const useGetRequest = ({ path, load = false, queryOptions, }) => {
     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) {
+            if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
                 updatePath(constructPaginationLink(requestPath, pagination.previous_page));
             }
         }
     };
     const constructPaginationLink = (link, pageNumber) => {
-        const oldParams = new URLSearchParams(link);
-        const oldPage = Number(oldParams.get('page'));
-        const [pathname, queryStrings] = link.split('?', 1);
-        const queryParams = new URLSearchParams(queryStrings ?? '');
+        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
@@ -72,12 +88,12 @@ const useGetRequest = ({ path, load = false, queryOptions, }) => {
         updatePath(constructPaginationLink(requestPath, pageNumber));
     };
     const updatedPathAsync = async (link) => {
-        react.startTransition(() => {
+        startTransition(() => {
             updatePath(link);
         });
     };
     const setOptionsAsync = async (fetchOptions) => {
-        react.startTransition(() => {
+        startTransition(() => {
             setOptions(fetchOptions);
         });
     };
@@ -98,5 +114,5 @@ const useGetRequest = ({ path, load = false, queryOptions, }) => {
     };
 };
 
-exports.useGetRequest = useGetRequest;
+export { useGetRequest };
 //# sourceMappingURL=useGetRequest.js.map

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,9 +1,9 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request/request.interface';
-export declare const usePatchRequest: <TResponse>({ path, }: {
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     path: string;
-    isFormData?: boolean | undefined;
-}) => {
+} & DefaultRequestOptions) => {
     data: undefined;
     error: null;
     isError: false;
@@ -19,7 +19,7 @@ export declare const usePatchRequest: <TResponse>({ path, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
     data: undefined;
     error: null;
@@ -36,7 +36,7 @@ export declare const usePatchRequest: <TResponse>({ path, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
     data: undefined;
     error: IRequestError;
@@ -53,7 +53,7 @@ export declare const usePatchRequest: <TResponse>({ path, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
     data: IRequestSuccess<TResponse>;
     error: null;
@@ -70,5 +70,5 @@ export declare const usePatchRequest: <TResponse>({ path, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 };