@ventlio/tanstack-query 0.5.4 → 0.5.5

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/model/index.d.ts

@@ -1,4 +1,4 @@
-export * from './model.interface';
-export * from './useKeyTrackerModel';
-export * from './useQueryModel';
-export * from './useRefetchQuery';
+export * from './model.interface';
+export * from './useKeyTrackerModel';
+export * from './useQueryModel';
+export * from './useRefetchQuery';

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

@@ -1,11 +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';
+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

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

package/dist/model/useKeyTrackerModel.js

@@ -1,19 +1,19 @@
 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 };
+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 };

package/dist/model/useQueryModel.d.ts

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

package/dist/model/useQueryModel.js

@@ -7,121 +7,121 @@ import '../stores/useHeaderStore.js';
 import '../stores/usePauseFutureRequests.js';
 import { useKeyTrackerModel } from './useKeyTrackerModel.js';
 
-const useQueryModel = (keyTracker) => {
-    const queryClient = useQueryClient();
-    const { getQueryKey } = useKeyTrackerModel(keyTracker);
-    const queryKey = getQueryKey();
-    const config = useQueryConfig();
-    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) ?? {};
-            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
-        }
-        return data;
-    };
-    const findAll = (path) => {
-        const data = queryClient.getQueryData(queryKey);
-        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);
-        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 } = 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) ?? {};
-            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) ?? {};
-            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
-        }
-        return updated;
-    };
-    return { find, findAll, findMany, remove, update, add, get, set };
+const useQueryModel = (keyTracker) => {
+    const queryClient = useQueryClient();
+    const { getQueryKey } = useKeyTrackerModel(keyTracker);
+    const queryKey = getQueryKey();
+    const config = useQueryConfig();
+    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) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
+        }
+        return data;
+    };
+    const findAll = (path) => {
+        const data = queryClient.getQueryData(queryKey);
+        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);
+        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 } = 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) ?? {};
+            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) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
+        }
+        return updated;
+    };
+    return { find, findAll, findMany, remove, update, add, get, set };
 };
 
 export { useQueryModel };

package/dist/model/useRefetchQuery.d.ts

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

package/dist/model/useRefetchQuery.js

@@ -1,15 +1,15 @@
 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({ queryKey: innerQueryKey ?? queryKey });
-    };
-    return { refetchQuery };
+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({ queryKey: innerQueryKey ?? queryKey });
+    };
+    return { refetchQuery };
 };
 
 export { useRefetchQuery };

package/dist/queries/index.d.ts

@@ -1,6 +1,6 @@
-export * from './queries.interface';
-export * from './useDeleteRequest';
-export * from './useGetInfiniteRequest';
-export * from './useGetRequest';
-export * from './usePatchRequest';
-export * from './usePostRequest';
+export * from './queries.interface';
+export * from './useDeleteRequest';
+export * from './useGetInfiniteRequest';
+export * from './useGetRequest';
+export * from './usePatchRequest';
+export * from './usePostRequest';

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

@@ -1,17 +1,17 @@
-import type { UseInfiniteQueryOptions, UseQueryOptions } from '@tanstack/react-query';
-import type { RawAxiosRequestHeaders } from 'axios';
-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>>;
-export type TanstackInfiniteQueryOption<TResponse> = Partial<UseInfiniteQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>>;
-export interface DefaultRequestOptions {
-    baseUrl?: string;
-    headers?: RawAxiosRequestHeaders;
-}
+import type { UseInfiniteQueryOptions, UseQueryOptions } from '@tanstack/react-query';
+import type { RawAxiosRequestHeaders } from 'axios';
+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>>;
+export type TanstackInfiniteQueryOption<TResponse> = Partial<UseInfiniteQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>>;
+export interface DefaultRequestOptions {
+    baseUrl?: string;
+    headers?: RawAxiosRequestHeaders;
+}

package/dist/queries/useDeleteRequest.d.ts

@@ -1,60 +1,60 @@
-import type { UseQueryOptions } from '@tanstack/react-query';
-import type { IRequestError, IRequestSuccess } from '../request';
-import type { DefaultRequestOptions } from './queries.interface';
-export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultRequestOptions) => {
-    isLoading: boolean;
-    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;
-    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
-        cached?: boolean | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-} | {
-    isLoading: boolean;
-    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;
-    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
-        cached?: boolean | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-};
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultRequestOptions) => {
+    isLoading: boolean;
+    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;
+    destroy: (link: string, internalDeleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>> & {
+        cached?: boolean;
+    }) => Promise<IRequestSuccess<TResponse> | undefined>;
+} | {
+    isLoading: boolean;
+    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;
+    destroy: (link: string, internalDeleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>> & {
+        cached?: boolean;
+    }) => Promise<IRequestSuccess<TResponse> | undefined>;
+};