@tanstack/preact-query 5.103.3 → 5.104.0

package/build/legacy/useSuspenseQuery.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
+{"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}

package/build/legacy/useSuspenseQuery.d.ts

@@ -88,7 +88,6 @@ import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
  * }
  * ```
  */
-declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
+export declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
 //#endregion
-export { useSuspenseQuery };
 //# sourceMappingURL=useSuspenseQuery.d.ts.map

package/build/legacy/useSuspenseQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}
+{"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8FgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}

package/build/legacy/utils.d.cts

@@ -1,6 +1,5 @@
 //#region src/utils.d.ts
-declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
-declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
+export declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
+export declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
 //#endregion
-export { useSyncExternalStore, useSyncExternalStoreWithSelector };
 //# sourceMappingURL=utils.d.cts.map

package/build/legacy/utils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";iBAegB,qBACd,YAAY,0CACZ;iBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/utils.ts"],"mappings":";wBAegB,qBACd,YAAY,0CACZ;wBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}

package/build/legacy/utils.d.ts

@@ -1,6 +1,5 @@
 //#region src/utils.d.ts
-declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
-declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
+export declare function useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => any): any;
+export declare function useSyncExternalStoreWithSelector<TSnapshot, TSelected>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => TSnapshot, selector: (snapshot: TSnapshot) => TSelected, isEqual: (a: TSelected, b: TSelected) => boolean): TSelected;
 //#endregion
-export { useSyncExternalStore, useSyncExternalStoreWithSelector };
 //# sourceMappingURL=utils.d.ts.map

package/build/legacy/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";iBAegB,qBACd,YAAY,0CACZ;iBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/utils.ts"],"mappings":";wBAegB,qBACd,YAAY,0CACZ;wBA8Cc,iCAAiC,WAAW,WAC1D,YAAY,0CACZ,mBAAmB,WACnB,WAAW,UAAU,cAAc,WACnC,UAAU,GAAG,WAAW,GAAG,wBAC1B"}

package/build/modern/HydrationBoundary.d.cts

@@ -4,7 +4,7 @@ import { ComponentChildren } from "preact";
 /**
  * The props accepted by `HydrationBoundary`.
  */
-interface HydrationBoundaryProps {
+export interface HydrationBoundaryProps {
   /**
    * The state to hydrate.
    */
@@ -70,7 +70,6 @@ interface HydrationBoundaryProps {
  * }
  * ```
  */
-declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
+export declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
 //#endregion
-export { HydrationBoundary, HydrationBoundaryProps };
 //# sourceMappingURL=HydrationBoundary.d.cts.map

package/build/modern/HydrationBoundary.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"HydrationBoundary.d.cts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;UAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
+{"version":3,"file":"HydrationBoundary.d.cts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;iBAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}

package/build/modern/HydrationBoundary.d.ts

@@ -4,7 +4,7 @@ import { ComponentChildren } from "preact";
 /**
  * The props accepted by `HydrationBoundary`.
  */
-interface HydrationBoundaryProps {
+export interface HydrationBoundaryProps {
   /**
    * The state to hydrate.
    */
@@ -70,7 +70,6 @@ interface HydrationBoundaryProps {
  * }
  * ```
  */
-declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
+export declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => import("preact").JSX.Element;
 //#endregion
-export { HydrationBoundary, HydrationBoundaryProps };
 //# sourceMappingURL=HydrationBoundary.d.ts.map

package/build/modern/HydrationBoundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;UAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}
+{"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;;;;iBAgBiB;;;;EAIf,OAAO;;;;EAIP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;;;;;;;EAUZ,WAAW;;;;EAIX,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8CH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,4CAAsB,IAAA"}

package/build/modern/IsRestoringProvider.d.cts

@@ -6,12 +6,11 @@
  *
  * @returns `true` while a persisted client is being restored, `false` otherwise.
  */
-declare const useIsRestoring: () => boolean;
+export declare const useIsRestoring: () => boolean;
 /**
  * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
  * being restored, read by `useIsRestoring`.
  */
-declare const IsRestoringProvider: import("preact").Provider<boolean>;
+export declare const IsRestoringProvider: import("preact").Provider<boolean>;
 //#endregion
-export { IsRestoringProvider, useIsRestoring };
 //# sourceMappingURL=IsRestoringProvider.d.cts.map

package/build/modern/IsRestoringProvider.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;cAYa;;;;;cAMA,sCAAmB"}
+{"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;qBAYa;;;;;qBAMA,sCAAmB"}

package/build/modern/IsRestoringProvider.d.ts

@@ -6,12 +6,11 @@
  *
  * @returns `true` while a persisted client is being restored, `false` otherwise.
  */
-declare const useIsRestoring: () => boolean;
+export declare const useIsRestoring: () => boolean;
 /**
  * The Provider that `PersistQueryClientProvider` uses to signal whether a persisted client is currently
  * being restored, read by `useIsRestoring`.
  */
-declare const IsRestoringProvider: import("preact").Provider<boolean>;
+export declare const IsRestoringProvider: import("preact").Provider<boolean>;
 //#endregion
-export { IsRestoringProvider, useIsRestoring };
 //# sourceMappingURL=IsRestoringProvider.d.ts.map

package/build/modern/IsRestoringProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;cAYa;;;;;cAMA,sCAAmB"}
+{"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;;;;;;;qBAYa;;;;;qBAMA,sCAAmB"}

package/build/modern/QueryClientProvider.d.cts

@@ -4,7 +4,7 @@ import { ComponentChildren, VNode } from "preact";
 /**
  * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
  */
-declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
+export declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
 /**
  * The `useQueryClient` hook returns the current `QueryClient` instance.
  *
@@ -13,11 +13,11 @@ declare const QueryClientContext: import("preact").Context<QueryClient | undefin
  * @returns The current `QueryClient` instance.
  * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
  */
-declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
 /**
  * The props accepted by `QueryClientProvider`.
  */
-type QueryClientProviderProps = {
+export type QueryClientProviderProps = {
   /**
    * **Required**
    *
@@ -48,7 +48,6 @@ type QueryClientProviderProps = {
  * }
  * ```
  */
-declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
+export declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
 //#endregion
-export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
 //# sourceMappingURL=QueryClientProvider.d.cts.map

package/build/modern/QueryClientProvider.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;cAQa,qCAAkB,QAAA;;;;;;;;;cAYlB,iBAAkB,cAAc,gBAAW;;;;KAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;cAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}
+{"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;qBAQa,qCAAkB,QAAA;;;;;;;;;qBAYlB,iBAAkB,cAAc,gBAAW;;;;YAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;qBAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}

package/build/modern/QueryClientProvider.d.ts

@@ -4,7 +4,7 @@ import { ComponentChildren, VNode } from "preact";
 /**
  * The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
  */
-declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
+export declare const QueryClientContext: import("preact").Context<QueryClient | undefined>;
 /**
  * The `useQueryClient` hook returns the current `QueryClient` instance.
  *
@@ -13,11 +13,11 @@ declare const QueryClientContext: import("preact").Context<QueryClient | undefin
  * @returns The current `QueryClient` instance.
  * @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
  */
-declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
 /**
  * The props accepted by `QueryClientProvider`.
  */
-type QueryClientProviderProps = {
+export type QueryClientProviderProps = {
   /**
    * **Required**
    *
@@ -48,7 +48,6 @@ type QueryClientProviderProps = {
  * }
  * ```
  */
-declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
+export declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => VNode;
 //#endregion
-export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
 //# sourceMappingURL=QueryClientProvider.d.ts.map

package/build/modern/QueryClientProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;cAQa,qCAAkB,QAAA;;;;;;;;;cAYlB,iBAAkB,cAAc,gBAAW;;;;KAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;cAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}
+{"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;;;;qBAQa,qCAAkB,QAAA;;;;;;;;;qBAYlB,iBAAkB,cAAc,gBAAW;;;;YAiB5C;;;;;;EAMV,QAAQ;;;;EAIR,WAAW;;;;;;;;;;;;;;;;;;;;;qBAsBA,wBAAuB,QAAA,YAGjC,6BAA2B"}

package/build/modern/QueryErrorResetBoundary.d.cts

@@ -3,16 +3,16 @@ import { ComponentChildren } from "preact";
 /**
  * Resets any query errors within the boundary, so queries know they can try again.
  */
-type QueryErrorResetFunction = () => void;
+export type QueryErrorResetFunction = () => void;
 /**
  * Returns whether the boundary has been reset and not yet cleared.
  */
-type QueryErrorIsResetFunction = () => boolean;
+export type QueryErrorIsResetFunction = () => boolean;
 /**
  * Clears the reset state, so queries know not to try again until the boundary is reset again.
  */
-type QueryErrorClearResetFunction = () => void;
-interface QueryErrorResetBoundaryValue {
+export type QueryErrorClearResetFunction = () => void;
+export interface QueryErrorResetBoundaryValue {
   /**
    * Clears the reset state, so queries know not to try again until the boundary is reset again.
    */
@@ -55,18 +55,18 @@ interface QueryErrorResetBoundaryValue {
  * }
  * ```
  */
-declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
+export declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
 /**
  * A render-prop function usable as `children` on `QueryErrorResetBoundary`.
  *
  * @param value - The boundary's {@link QueryErrorResetBoundaryValue}.
  * @returns The children to render.
  */
-type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
+export type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
 /**
  * The props accepted by `QueryErrorResetBoundary`.
  */
-interface QueryErrorResetBoundaryProps {
+export interface QueryErrorResetBoundaryProps {
   /**
    * Either a plain node, or a function that receives the boundary's {@link QueryErrorResetBoundaryValue} and
    * returns a node.
@@ -121,7 +121,6 @@ interface QueryErrorResetBoundaryProps {
  * }
  * ```
  */
-declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
+export declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
 //#endregion
-export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
 //# sourceMappingURL=QueryErrorResetBoundary.d.cts.map

package/build/modern/QueryErrorResetBoundary.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryErrorResetBoundary.d.cts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;KASY;;;;KAKA;;;;KAKA;UAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDI,kCAA0B;;;;;;;KAW3B,mCACV,OAAO,iCACJ;;;;UAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}
+{"version":3,"file":"QueryErrorResetBoundary.d.cts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;YASY;;;;YAKA;;;;YAKA;iBAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDI,kCAA0B;;;;;;;YAW3B,mCACV,OAAO,iCACJ;;;;iBAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}

package/build/modern/QueryErrorResetBoundary.d.ts

@@ -3,16 +3,16 @@ import { ComponentChildren } from "preact";
 /**
  * Resets any query errors within the boundary, so queries know they can try again.
  */
-type QueryErrorResetFunction = () => void;
+export type QueryErrorResetFunction = () => void;
 /**
  * Returns whether the boundary has been reset and not yet cleared.
  */
-type QueryErrorIsResetFunction = () => boolean;
+export type QueryErrorIsResetFunction = () => boolean;
 /**
  * Clears the reset state, so queries know not to try again until the boundary is reset again.
  */
-type QueryErrorClearResetFunction = () => void;
-interface QueryErrorResetBoundaryValue {
+export type QueryErrorClearResetFunction = () => void;
+export interface QueryErrorResetBoundaryValue {
   /**
    * Clears the reset state, so queries know not to try again until the boundary is reset again.
    */
@@ -55,18 +55,18 @@ interface QueryErrorResetBoundaryValue {
  * }
  * ```
  */
-declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
+export declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
 /**
  * A render-prop function usable as `children` on `QueryErrorResetBoundary`.
  *
  * @param value - The boundary's {@link QueryErrorResetBoundaryValue}.
  * @returns The children to render.
  */
-type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
+export type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => ComponentChildren;
 /**
  * The props accepted by `QueryErrorResetBoundary`.
  */
-interface QueryErrorResetBoundaryProps {
+export interface QueryErrorResetBoundaryProps {
   /**
    * Either a plain node, or a function that receives the boundary's {@link QueryErrorResetBoundaryValue} and
    * returns a node.
@@ -121,7 +121,6 @@ interface QueryErrorResetBoundaryProps {
  * }
  * ```
  */
-declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
+export declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("preact").JSX.Element;
 //#endregion
-export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
 //# sourceMappingURL=QueryErrorResetBoundary.d.ts.map

package/build/modern/QueryErrorResetBoundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryErrorResetBoundary.d.ts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;KASY;;;;KAKA;;;;KAKA;UAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDI,kCAA0B;;;;;;;KAW3B,mCACV,OAAO,iCACJ;;;;UAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}
+{"version":3,"file":"QueryErrorResetBoundary.d.ts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;;;;YASY;;;;YAKA;;;;YAKA;iBAEK;;;;EAIf,YAAY;;;;EAIZ,SAAS;;;;EAIT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDI,kCAA0B;;;;;;;YAW3B,mCACV,OAAO,iCACJ;;;;iBAKY;;;;;EAKf,UAAU,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDjC,4BAA2B,YAErC,kDAA4B,IAAA"}

package/build/modern/errorBoundaryUtils.d.cts

@@ -1,9 +1,9 @@
 import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.cjs";
 import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
 //#region src/errorBoundaryUtils.d.ts
-declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
-declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
-declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
+export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
+export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
+export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
   result: QueryObserverResult<TData, TError>;
   errorResetBoundary: QueryErrorResetBoundaryValue;
   throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
@@ -11,5 +11,4 @@ declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey e
   suspense: boolean | undefined;
 }) => boolean | undefined;
 //#endregion
-export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
 //# sourceMappingURL=errorBoundaryUtils.d.cts.map

package/build/modern/errorBoundaryUtils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"errorBoundaryUtils.d.cts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;cAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;cAepC,6BACX,oBAAoB;cAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}
+{"version":3,"file":"errorBoundaryUtils.d.cts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;qBAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;qBAepC,6BACX,oBAAoB;qBAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}

package/build/modern/errorBoundaryUtils.d.ts

@@ -1,9 +1,9 @@
 import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.js";
 import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
 //#region src/errorBoundaryUtils.d.ts
-declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
-declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
-declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
+export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => void;
+export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
+export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
   result: QueryObserverResult<TData, TError>;
   errorResetBoundary: QueryErrorResetBoundaryValue;
   throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
@@ -11,5 +11,4 @@ declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey e
   suspense: boolean | undefined;
 }) => boolean | undefined;
 //#endregion
-export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
 //# sourceMappingURL=errorBoundaryUtils.d.ts.map

package/build/modern/errorBoundaryUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errorBoundaryUtils.d.ts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;cAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;cAepC,6BACX,oBAAoB;cAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}
+{"version":3,"file":"errorBoundaryUtils.d.ts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;qBAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;qBAepC,6BACX,oBAAoB;qBAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}

package/build/modern/infiniteQueryOptions.d.cts

@@ -12,7 +12,7 @@ import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, Omi
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -34,7 +34,7 @@ type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TD
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
+export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
   /**
    * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
    * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
@@ -54,7 +54,7 @@ type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData =
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -105,7 +105,7 @@ type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TDat
  * }
  * ```
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to `useInfiniteQuery`.
  * These options can be shared across hooks and imperative APIs such as `queryClient.infiniteQuery`.
@@ -145,7 +145,7 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
  * @see {@link useInfiniteQuery} to run an infinite query with these options.
  * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to `useInfiniteQuery`.
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to `useInfiniteQuery`.
  * These options can be shared across hooks and imperative APIs such as `queryClient.infiniteQuery`.
@@ -185,7 +185,6 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
  * @see {@link useInfiniteQuery} to run an infinite query with these options.
  * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to `useInfiniteQuery`.
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 //#endregion
-export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
 //# sourceMappingURL=infiniteQueryOptions.d.cts.map

package/build/modern/infiniteQueryOptions.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"infiniteQueryOptions.d.cts","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"mappings":";;;;;;;;;;;;;;KAwBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;KAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,wBAAwB,cAAc,QAAQ,OAAO,WAAW;;;;;;;EAShE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;KAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6C1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}
+{"version":3,"file":"infiniteQueryOptions.d.cts","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"mappings":";;;;;;;;;;;;;;YAwBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;YAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,wBAAwB,cAAc,QAAQ,OAAO,WAAW;;;;;;;EAShE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;YAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6C1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}

package/build/modern/infiniteQueryOptions.d.ts

@@ -12,7 +12,7 @@ import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, Omi
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -34,7 +34,7 @@ type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TD
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
+export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
   /**
    * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
    * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
@@ -54,7 +54,7 @@ type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData =
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -105,7 +105,7 @@ type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TDat
  * }
  * ```
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to `useInfiniteQuery`.
  * These options can be shared across hooks and imperative APIs such as `queryClient.infiniteQuery`.
@@ -145,7 +145,7 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
  * @see {@link useInfiniteQuery} to run an infinite query with these options.
  * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to `useInfiniteQuery`.
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to `useInfiniteQuery`.
  * These options can be shared across hooks and imperative APIs such as `queryClient.infiniteQuery`.
@@ -185,7 +185,6 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
  * @see {@link useInfiniteQuery} to run an infinite query with these options.
  * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to `useInfiniteQuery`.
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 //#endregion
-export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
 //# sourceMappingURL=infiniteQueryOptions.d.ts.map

package/build/modern/infiniteQueryOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"infiniteQueryOptions.d.ts","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"mappings":";;;;;;;;;;;;;;KAwBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;KAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,wBAAwB,cAAc,QAAQ,OAAO,WAAW;;;;;;;EAShE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;KAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6C1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}
+{"version":3,"file":"infiniteQueryOptions.d.ts","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"mappings":";;;;;;;;;;;;;;YAwBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;YAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,wBAAwB,cAAc,QAAQ,OAAO,WAAW;;;;;;;EAShE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;YAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6C1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyC7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}

package/build/modern/mutationOptions.d.cts

@@ -30,7 +30,7 @@ import { DefaultError, WithRequired } from "@tanstack/query-core";
  * }
  * ```
  */
-declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 /**
  * You can generally pass everything to `mutationOptions` that you can also pass to `useMutation`. No
  * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a
@@ -57,7 +57,6 @@ declare function mutationOptions<TData = unknown, TError = DefaultError, TVariab
  * }
  * ```
  */
-declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 //#endregion
-export { mutationOptions };
 //# sourceMappingURL=mutationOptions.d.cts.map

package/build/modern/mutationOptions.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"mutationOptions.d.cts","names":[],"sources":["../../src/mutationOptions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,aACD,mBAAmB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BhC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,KACD,mBAAmB,OAAO,QAAQ,YAAY"}
+{"version":3,"file":"mutationOptions.d.cts","names":[],"sources":["../../src/mutationOptions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,aACD,mBAAmB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BhC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,KACD,mBAAmB,OAAO,QAAQ,YAAY"}

package/build/modern/mutationOptions.d.ts

@@ -30,7 +30,7 @@ import { DefaultError, WithRequired } from "@tanstack/query-core";
  * }
  * ```
  */
-declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 /**
  * You can generally pass everything to `mutationOptions` that you can also pass to `useMutation`. No
  * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a
@@ -57,7 +57,6 @@ declare function mutationOptions<TData = unknown, TError = DefaultError, TVariab
  * }
  * ```
  */
-declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 //#endregion
-export { mutationOptions };
 //# sourceMappingURL=mutationOptions.d.ts.map

package/build/modern/mutationOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutationOptions.d.ts","names":[],"sources":["../../src/mutationOptions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,aACD,mBAAmB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BhC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,KACD,mBAAmB,OAAO,QAAQ,YAAY"}
+{"version":3,"file":"mutationOptions.d.ts","names":[],"sources":["../../src/mutationOptions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,aACD,mBAAmB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BhC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,KACD,mBAAmB,OAAO,QAAQ,YAAY"}