@navios/react-query 0.6.1 → 0.7.1

package/lib/index.mjs

@@ -1,366 +1,405 @@
-import { bindUrlParams } from '@navios/builder';
-import { useQuery, useSuspenseQuery, useInfiniteQuery, useSuspenseInfiniteQuery, useIsMutating, infiniteQueryOptions, useMutation, queryOptions } from '@tanstack/react-query';
+import { bindUrlParams } from "@navios/builder";
+import { infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsMutating, useMutation, useQuery, useSuspenseInfiniteQuery, useSuspenseQuery } from "@tanstack/react-query";
 
-// src/query/key-creator.mts
+//#region src/query/key-creator.mts
+/**
+* Creates a query key generator for a given endpoint configuration.
+*
+* The returned object provides methods to generate query keys that can be used
+* with TanStack Query for caching, invalidation, and data tagging.
+*
+* @param config - The endpoint configuration
+* @param options - Query parameters including processResponse and key prefix/suffix
+* @param isInfinite - Whether this is for an infinite query
+* @returns An object with methods to generate query keys
+*/
 function createQueryKey(config, options, _isInfinite) {
-  const url = config.url;
-  const urlParts = url.split("/").filter(Boolean);
-  return {
-    template: urlParts,
-    // @ts-expect-error We have correct types in return type
-    dataTag: (params) => {
-      const queryParams = params && "querySchema" in config && "params" in params ? config.querySchema?.parse(params.params) : [];
-      return [
-        ...options.keyPrefix ?? [],
-        ...urlParts.map(
-          (part) => part.startsWith("$") ? (
-            // @ts-expect-error TS2339 We know that the urlParams are defined only if the url has params
-            params.urlParams[part.slice(1)].toString()
-          ) : part
-        ),
-        ...options.keySuffix ?? [],
-        queryParams ?? []
-      ];
-    },
-    // @ts-expect-error We have correct types in return type
-    filterKey: (params) => {
-      return [
-        ...options.keyPrefix ?? [],
-        ...urlParts.map(
-          (part) => part.startsWith("$") ? (
-            // @ts-expect-error TS2339 We know that the urlParams are defined only if the url has params
-            params.urlParams[part.slice(1)].toString()
-          ) : part
-        ),
-        ...options.keySuffix ?? []
-      ];
-    },
-    bindToUrl: (params) => {
-      return bindUrlParams(url, params ?? {});
-    }
-  };
+	const url = config.url;
+	const urlParts = url.split("/").filter(Boolean);
+	return {
+		template: urlParts,
+		dataTag: (params) => {
+			const queryParams = params && "querySchema" in config && "params" in params ? config.querySchema?.parse(params.params) : [];
+			return [
+				...options.keyPrefix ?? [],
+				...urlParts.map((part) => part.startsWith("$") ? params.urlParams[part.slice(1)].toString() : part),
+				...options.keySuffix ?? [],
+				queryParams ?? []
+			];
+		},
+		filterKey: (params) => {
+			return [
+				...options.keyPrefix ?? [],
+				...urlParts.map((part) => part.startsWith("$") ? params.urlParams[part.slice(1)].toString() : part),
+				...options.keySuffix ?? []
+			];
+		},
+		bindToUrl: (params) => {
+			return bindUrlParams(url, params ?? {});
+		}
+	};
 }
-var queryKeyCreator = createQueryKey;
+/** @deprecated Use createQueryKey instead */
+const queryKeyCreator = createQueryKey;
+
+//#endregion
+//#region src/query/make-options.mts
+/**
+* Creates query options for a given endpoint.
+*
+* Returns a function that generates TanStack Query options when called with params.
+* The returned function also has helper methods attached (use, useSuspense, invalidate, etc.)
+*
+* @param endpoint - The navios endpoint to create query options for
+* @param options - Query configuration including processResponse
+* @param baseQuery - Optional base query options to merge
+* @returns A function that generates query options with attached helpers
+*/
 function makeQueryOptions(endpoint, options, baseQuery = {}) {
-  const config = endpoint.config;
-  const queryKey = createQueryKey(config, options);
-  const processResponse = options.processResponse;
-  const result = (params) => {
-    return queryOptions({
-      queryKey: queryKey.dataTag(params),
-      queryFn: async ({ signal }) => {
-        let result2;
-        try {
-          result2 = await endpoint({
-            signal,
-            ...params
-          });
-        } catch (err) {
-          if (options.onFail) {
-            options.onFail(err);
-          }
-          throw err;
-        }
-        return processResponse(result2);
-      },
-      ...baseQuery
-    });
-  };
-  result.queryKey = queryKey;
-  result.use = (params) => {
-    return useQuery(result(params));
-  };
-  result.useSuspense = (params) => {
-    return useSuspenseQuery(result(params));
-  };
-  result.invalidate = (queryClient, params) => {
-    return queryClient.invalidateQueries({
-      queryKey: result.queryKey.dataTag(params)
-    });
-  };
-  result.invalidateAll = (queryClient, params) => {
-    return queryClient.invalidateQueries({
-      queryKey: result.queryKey.filterKey(params),
-      exact: false
-    });
-  };
-  return result;
+	const config = endpoint.config;
+	const queryKey = createQueryKey(config, options, false);
+	const processResponse = options.processResponse;
+	const result = (params) => {
+		return queryOptions({
+			queryKey: queryKey.dataTag(params),
+			queryFn: async ({ signal }) => {
+				let result$1;
+				try {
+					result$1 = await endpoint({
+						signal,
+						...params
+					});
+				} catch (err) {
+					if (options.onFail) options.onFail(err);
+					throw err;
+				}
+				return processResponse(result$1);
+			},
+			...baseQuery
+		});
+	};
+	result.queryKey = queryKey;
+	result.use = (params) => {
+		return useQuery(result(params));
+	};
+	result.useSuspense = (params) => {
+		return useSuspenseQuery(result(params));
+	};
+	result.invalidate = (queryClient, params) => {
+		return queryClient.invalidateQueries({ queryKey: result.queryKey.dataTag(params) });
+	};
+	result.invalidateAll = (queryClient, params) => {
+		return queryClient.invalidateQueries({
+			queryKey: result.queryKey.filterKey(params),
+			exact: false
+		});
+	};
+	return result;
 }
+
+//#endregion
+//#region src/query/make-infinite-options.mts
+/**
+* Creates infinite query options for a given endpoint.
+*
+* Returns a function that generates TanStack Query infinite options when called with params.
+* The returned function also has helper methods attached (use, useSuspense, invalidate, etc.)
+*
+* @param endpoint - The navios endpoint to create infinite query options for
+* @param options - Infinite query configuration including processResponse and pagination params
+* @param baseQuery - Optional base query options to merge
+* @returns A function that generates infinite query options with attached helpers
+*/
 function makeInfiniteQueryOptions(endpoint, options, baseQuery = {}) {
-  const config = endpoint.config;
-  const queryKey = createQueryKey(config, options);
-  const processResponse = options.processResponse;
-  const res = (params) => {
-    return infiniteQueryOptions({
-      queryKey: queryKey.dataTag(params),
-      queryFn: async ({ signal, pageParam }) => {
-        let result;
-        try {
-          result = await endpoint({
-            signal,
-            // @ts-expect-error TS2345 We bind the url params only if the url has params
-            urlParams: params.urlParams,
-            params: {
-              ..."params" in params ? params.params : {},
-              ...pageParam
-            }
-          });
-        } catch (err) {
-          if (options.onFail) {
-            options.onFail(err);
-          }
-          throw err;
-        }
-        return processResponse(result);
-      },
-      getNextPageParam: options.getNextPageParam,
-      getPreviousPageParam: options.getPreviousPageParam,
-      initialPageParam: options.initialPageParam ?? config.querySchema.parse("params" in params ? params.params : {}),
-      ...baseQuery
-    });
-  };
-  res.queryKey = queryKey;
-  res.use = (params) => {
-    return useInfiniteQuery(res(params));
-  };
-  res.useSuspense = (params) => {
-    return useSuspenseInfiniteQuery(res(params));
-  };
-  res.invalidate = (queryClient, params) => {
-    return queryClient.invalidateQueries({
-      queryKey: res.queryKey.dataTag(params)
-    });
-  };
-  res.invalidateAll = (queryClient, params) => {
-    return queryClient.invalidateQueries({
-      queryKey: res.queryKey.filterKey(params),
-      exact: false
-    });
-  };
-  return res;
+	const config = endpoint.config;
+	const queryKey = createQueryKey(config, options, true);
+	const processResponse = options.processResponse;
+	const res = (params) => {
+		return infiniteQueryOptions({
+			queryKey: queryKey.dataTag(params),
+			queryFn: async ({ signal, pageParam }) => {
+				let result;
+				try {
+					result = await endpoint({
+						signal,
+						urlParams: params.urlParams,
+						params: {
+							..."params" in params ? params.params : {},
+							...pageParam
+						}
+					});
+				} catch (err) {
+					if (options.onFail) options.onFail(err);
+					throw err;
+				}
+				return processResponse(result);
+			},
+			getNextPageParam: options.getNextPageParam,
+			getPreviousPageParam: options.getPreviousPageParam,
+			initialPageParam: options.initialPageParam ?? config.querySchema.parse("params" in params ? params.params : {}),
+			...baseQuery
+		});
+	};
+	res.queryKey = queryKey;
+	res.use = (params) => {
+		return useInfiniteQuery(res(params));
+	};
+	res.useSuspense = (params) => {
+		return useSuspenseInfiniteQuery(res(params));
+	};
+	res.invalidate = (queryClient, params) => {
+		return queryClient.invalidateQueries({ queryKey: res.queryKey.dataTag(params) });
+	};
+	res.invalidateAll = (queryClient, params) => {
+		return queryClient.invalidateQueries({
+			queryKey: res.queryKey.filterKey(params),
+			exact: false
+		});
+	};
+	return res;
 }
 
-// src/mutation/key-creator.mts
-function createMutationKey(config, options = {
-  processResponse: (data) => data
-}) {
-  const queryKey = createQueryKey(config, options);
-  return (params) => {
-    return queryKey.filterKey(params);
-  };
+//#endregion
+//#region src/mutation/key-creator.mts
+/**
+* Creates a mutation key generator for a given endpoint configuration.
+*
+* @param config - The endpoint configuration
+* @param options - Optional query parameters with a default `processResponse` function
+* @returns A function that generates mutation keys
+*
+* @example Basic usage:
+* ```typescript
+* const createMutationKey = createMutationKey(endpoint.config);
+* const mutationKey = createMutationKey({ urlParams: { id: 123 } });
+* ```
+*
+* @example Advanced usage with processResponse:
+* ```ts
+* const createMutationKey = createMutationKey(endpoint.config, {
+*   processResponse: (data) => {
+*     if (!data.success) {
+*       throw new Error(data.message);
+*     }
+*     return data.data;
+*   },
+* });
+* // We create a mutation that will be shared across the project for all passed userId
+* const mutationKey = createMutationKey({ urlParams: { projectId: 123, userId: 'wildcard' } });
+* ```
+*/
+function createMutationKey(config, options = { processResponse: (data) => data }) {
+	const queryKey = createQueryKey(config, options, false);
+	return (params) => {
+		return queryKey.filterKey(params);
+	};
 }
-var mutationKeyCreator = createMutationKey;
+/** @deprecated Use createMutationKey instead */
+const mutationKeyCreator = createMutationKey;
+
+//#endregion
+//#region src/mutation/make-hook.mts
+/**
+* Creates a mutation hook for a given endpoint.
+*
+* Returns a function that when called returns a TanStack Query mutation result.
+* The returned function also has helper methods attached (mutationKey, useIsMutating).
+*
+* @param endpoint - The navios endpoint to create a mutation hook for
+* @param options - Mutation configuration including processResponse and callbacks
+* @returns A hook function that returns mutation result with attached helpers
+*/
 function makeMutation(endpoint, options) {
-  const config = endpoint.config;
-  const mutationKey = createMutationKey(config, {
-    ...options});
-  const result = (keyParams) => {
-    const {
-      useKey,
-      useContext,
-      onMutate,
-      onError,
-      onSuccess,
-      onSettled,
-      keyPrefix: _keyPrefix,
-      keySuffix: _keySuffix,
-      processResponse,
-      ...rest
-    } = options;
-    const ownContext = useContext?.() ?? {};
-    return useMutation({
-      ...rest,
-      mutationKey: useKey ? mutationKey({
-        urlParams: keyParams
-      }) : void 0,
-      scope: useKey ? {
-        id: JSON.stringify(
-          mutationKey({
-            urlParams: keyParams
-          })
-        )
-      } : void 0,
-      async mutationFn(params) {
-        const response = await endpoint(params);
-        return processResponse ? processResponse(response) : response;
-      },
-      onSuccess: onSuccess ? (data, variables, onMutateResult, context) => {
-        return onSuccess?.(data, variables, {
-          ...ownContext,
-          ...context,
-          onMutateResult
-        });
-      } : void 0,
-      onError: onError ? (err, variables, onMutateResult, context) => {
-        return onError?.(err, variables, {
-          onMutateResult,
-          ...ownContext,
-          ...context
-        });
-      } : void 0,
-      onMutate: onMutate ? (variables, context) => {
-        return onMutate(variables, {
-          ...ownContext,
-          ...context
-        });
-      } : void 0,
-      onSettled: onSettled ? (data, error, variables, onMutateResult, context) => {
-        return onSettled(data, error, variables, {
-          ...ownContext,
-          ...context,
-          onMutateResult
-        });
-      } : void 0
-    });
-  };
-  result.useIsMutating = (keyParams) => {
-    if (!options.useKey) {
-      throw new Error(
-        "useIsMutating can only be used when useKey is set to true"
-      );
-    }
-    const isMutating = useIsMutating({
-      mutationKey: mutationKey({
-        urlParams: keyParams
-      })
-    });
-    return isMutating > 0;
-  };
-  result.mutationKey = mutationKey;
-  return result;
+	const config = endpoint.config;
+	const mutationKey = createMutationKey(config, {
+		...options,
+		processResponse: options.processResponse ?? ((data) => data)
+	});
+	const result = (keyParams) => {
+		const { useKey, useContext, onMutate, onError, onSuccess, onSettled, keyPrefix: _keyPrefix, keySuffix: _keySuffix, processResponse, ...rest } = options;
+		const ownContext = useContext?.() ?? {};
+		return useMutation({
+			...rest,
+			mutationKey: useKey ? mutationKey(keyParams) : void 0,
+			scope: useKey ? { id: JSON.stringify(mutationKey(keyParams)) } : void 0,
+			async mutationFn(params) {
+				const response = await endpoint(params);
+				return processResponse ? processResponse(response) : response;
+			},
+			onSuccess: onSuccess ? (data, variables, onMutateResult, context) => {
+				return onSuccess?.(data, variables, {
+					...ownContext,
+					...context,
+					onMutateResult
+				});
+			} : void 0,
+			onError: onError ? (err, variables, onMutateResult, context) => {
+				return onError?.(err, variables, {
+					onMutateResult,
+					...ownContext,
+					...context
+				});
+			} : void 0,
+			onMutate: onMutate ? (variables, context) => {
+				return onMutate(variables, {
+					...ownContext,
+					...context
+				});
+			} : void 0,
+			onSettled: onSettled ? (data, error, variables, onMutateResult, context) => {
+				return onSettled(data, error, variables, {
+					...ownContext,
+					...context,
+					onMutateResult
+				});
+			} : void 0
+		});
+	};
+	result.useIsMutating = (keyParams) => {
+		if (!options.useKey) throw new Error("useIsMutating can only be used when useKey is set to true");
+		return useIsMutating({ mutationKey: mutationKey({ urlParams: keyParams }) }) > 0;
+	};
+	result.mutationKey = mutationKey;
+	return result;
 }
 
-// src/client/declare-client.mts
-function declareClient({
-  api,
-  defaults = {}
-}) {
-  function query(config) {
-    const endpoint = api.declareEndpoint({
-      // @ts-expect-error we accept only specific methods
-      method: config.method,
-      url: config.url,
-      querySchema: config.querySchema,
-      requestSchema: config.requestSchema,
-      responseSchema: config.responseSchema
-    });
-    const queryOptions2 = makeQueryOptions(endpoint, {
-      ...defaults,
-      processResponse: config.processResponse ?? ((data) => data)
-    });
-    queryOptions2.endpoint = endpoint;
-    return queryOptions2;
-  }
-  function queryFromEndpoint(endpoint, options) {
-    return makeQueryOptions(endpoint, {
-      ...defaults,
-      processResponse: options?.processResponse ?? ((data) => data)
-    });
-  }
-  function infiniteQuery(config) {
-    const endpoint = api.declareEndpoint({
-      // @ts-expect-error we accept only specific methods
-      method: config.method,
-      url: config.url,
-      querySchema: config.querySchema,
-      requestSchema: config.requestSchema,
-      responseSchema: config.responseSchema
-    });
-    const infiniteQueryOptions2 = makeInfiniteQueryOptions(endpoint, {
-      ...defaults,
-      processResponse: config.processResponse ?? ((data) => data),
-      getNextPageParam: config.getNextPageParam,
-      getPreviousPageParam: config.getPreviousPageParam,
-      initialPageParam: config.initialPageParam
-    });
-    infiniteQueryOptions2.endpoint = endpoint;
-    return infiniteQueryOptions2;
-  }
-  function infiniteQueryFromEndpoint(endpoint, options) {
-    return makeInfiniteQueryOptions(endpoint, {
-      ...defaults,
-      processResponse: options?.processResponse ?? ((data) => data),
-      getNextPageParam: options.getNextPageParam,
-      getPreviousPageParam: options?.getPreviousPageParam,
-      initialPageParam: options?.initialPageParam
-    });
-  }
-  function mutation(config) {
-    const endpoint = api.declareEndpoint({
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      method: config.method,
-      url: config.url,
-      querySchema: config.querySchema,
-      requestSchema: config.requestSchema,
-      responseSchema: config.responseSchema
-    });
-    const useMutation2 = makeMutation(endpoint, {
-      processResponse: config.processResponse ?? ((data) => data),
-      useContext: config.useContext,
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      onSuccess: config.onSuccess,
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      onError: config.onError,
-      useKey: config.useKey,
-      meta: config.meta,
-      ...defaults
-    });
-    useMutation2.endpoint = endpoint;
-    return useMutation2;
-  }
-  function mutationFromEndpoint(endpoint, options) {
-    return makeMutation(endpoint, {
-      processResponse: options?.processResponse,
-      useContext: options?.useContext,
-      onSuccess: options?.onSuccess,
-      onError: options?.onError,
-      ...defaults
-    });
-  }
-  function multipartMutation(config) {
-    const endpoint = api.declareMultipart({
-      // @ts-expect-error we accept only specific methods
-      method: config.method,
-      url: config.url,
-      querySchema: config.querySchema,
-      requestSchema: config.requestSchema,
-      responseSchema: config.responseSchema
-    });
-    const useMutation2 = makeMutation(endpoint, {
-      processResponse: config.processResponse ?? ((data) => data),
-      useContext: config.useContext,
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      onSuccess: config.onSuccess,
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      onError: config.onError,
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      onMutate: config.onMutate,
-      // @ts-expect-error We forgot about the DELETE method in original makeMutation
-      onSettled: config.onSettled,
-      useKey: config.useKey,
-      ...defaults
-    });
-    useMutation2.endpoint = endpoint;
-    return useMutation2;
-  }
-  return {
-    // @ts-expect-error We simplified types here
-    query,
-    // @ts-expect-error We simplified types here
-    queryFromEndpoint,
-    // @ts-expect-error We simplified types here
-    infiniteQuery,
-    // @ts-expect-error We simplified types here
-    infiniteQueryFromEndpoint,
-    // @ts-expect-error We simplified types here
-    mutation,
-    // @ts-expect-error We simplified types here
-    mutationFromEndpoint,
-    // @ts-expect-error We simplified types here
-    multipartMutation
-  };
+//#endregion
+//#region src/client/declare-client.mts
+/**
+* Creates a client instance for making type-safe queries and mutations.
+*
+* @param options - Client configuration including the API builder and defaults
+* @returns A client instance with query, infiniteQuery, and mutation methods
+*
+* @example
+* ```typescript
+* const api = createBuilder({ baseUrl: '/api' });
+* const client = declareClient({ api });
+*
+* const getUser = client.query({
+*   method: 'GET',
+*   url: '/users/$id',
+*   responseSchema: UserSchema,
+* });
+*
+* // In a component
+* const { data } = useSuspenseQuery(getUser({ urlParams: { id: '123' } }));
+* ```
+*/
+function declareClient({ api, defaults = {} }) {
+	function query(config) {
+		const endpoint = api.declareEndpoint({
+			method: config.method,
+			url: config.url,
+			querySchema: config.querySchema,
+			requestSchema: config.requestSchema,
+			responseSchema: config.responseSchema
+		});
+		const queryOptions$1 = makeQueryOptions(endpoint, {
+			...defaults,
+			processResponse: config.processResponse ?? ((data) => data)
+		});
+		queryOptions$1.endpoint = endpoint;
+		return queryOptions$1;
+	}
+	function queryFromEndpoint(endpoint, options) {
+		return makeQueryOptions(endpoint, {
+			...defaults,
+			processResponse: options?.processResponse ?? ((data) => data)
+		});
+	}
+	function infiniteQuery(config) {
+		const endpoint = api.declareEndpoint({
+			method: config.method,
+			url: config.url,
+			querySchema: config.querySchema,
+			requestSchema: config.requestSchema,
+			responseSchema: config.responseSchema
+		});
+		const infiniteQueryOptions$1 = makeInfiniteQueryOptions(endpoint, {
+			...defaults,
+			processResponse: config.processResponse ?? ((data) => data),
+			getNextPageParam: config.getNextPageParam,
+			getPreviousPageParam: config.getPreviousPageParam,
+			initialPageParam: config.initialPageParam
+		});
+		infiniteQueryOptions$1.endpoint = endpoint;
+		return infiniteQueryOptions$1;
+	}
+	function infiniteQueryFromEndpoint(endpoint, options) {
+		return makeInfiniteQueryOptions(endpoint, {
+			...defaults,
+			processResponse: options?.processResponse ?? ((data) => data),
+			getNextPageParam: options.getNextPageParam,
+			getPreviousPageParam: options?.getPreviousPageParam,
+			initialPageParam: options?.initialPageParam
+		});
+	}
+	function mutation(config) {
+		const endpoint = api.declareEndpoint({
+			method: config.method,
+			url: config.url,
+			querySchema: config.querySchema,
+			requestSchema: config.requestSchema,
+			responseSchema: config.responseSchema
+		});
+		const useMutation$1 = makeMutation(endpoint, {
+			processResponse: config.processResponse ?? ((data) => data),
+			useContext: config.useContext,
+			onSuccess: config.onSuccess,
+			onError: config.onError,
+			useKey: config.useKey,
+			meta: config.meta,
+			...defaults
+		});
+		useMutation$1.endpoint = endpoint;
+		return useMutation$1;
+	}
+	function mutationFromEndpoint(endpoint, options) {
+		return makeMutation(endpoint, {
+			processResponse: options?.processResponse,
+			useContext: options?.useContext,
+			onMutate: options?.onMutate,
+			onSuccess: options?.onSuccess,
+			onError: options?.onError,
+			onSettled: options?.onSettled,
+			useKey: options?.useKey,
+			meta: options?.meta,
+			...defaults
+		});
+	}
+	function multipartMutation(config) {
+		const endpoint = api.declareMultipart({
+			method: config.method,
+			url: config.url,
+			querySchema: config.querySchema,
+			requestSchema: config.requestSchema,
+			responseSchema: config.responseSchema
+		});
+		const useMutation$1 = makeMutation(endpoint, {
+			processResponse: config.processResponse ?? ((data) => data),
+			useContext: config.useContext,
+			onSuccess: config.onSuccess,
+			onError: config.onError,
+			onMutate: config.onMutate,
+			onSettled: config.onSettled,
+			useKey: config.useKey,
+			...defaults
+		});
+		useMutation$1.endpoint = endpoint;
+		return useMutation$1;
+	}
+	return {
+		query,
+		queryFromEndpoint,
+		infiniteQuery,
+		infiniteQueryFromEndpoint,
+		mutation,
+		mutationFromEndpoint,
+		multipartMutation
+	};
 }
 
+//#endregion
 export { createMutationKey, createQueryKey, declareClient, makeInfiniteQueryOptions, makeMutation, makeQueryOptions, mutationKeyCreator, queryKeyCreator };
-//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map