@depup/reduxjs__toolkit 2.12.0-depup.28 → 2.13.0-depup.0

package/dist/query/react/index.d.ts

@@ -1,35 +1,40 @@
-import * as _reduxjs_toolkit_query from '@reduxjs/toolkit/query';
-import { QueryDefinition, TSHelpersId, TSHelpersOverride, QuerySubState, ResultTypeFrom, QueryStatus, QueryArgFrom, SkipToken, SubscriptionOptions, QueryActionCreatorResult, MutationDefinition, MutationResultSelectorResult, MutationActionCreatorResult, InfiniteQueryDefinition, InfiniteQuerySubState, PageParamFrom, InfiniteQueryArgFrom, InfiniteQueryActionCreatorResult, BaseQueryFn, EndpointDefinitions, DefinitionType, QueryKeys, PrefetchOptions, Module, Api, setupListeners } from '@reduxjs/toolkit/query';
-export * from '@reduxjs/toolkit/query';
-import * as react_redux from 'react-redux';
-import { ReactReduxContextValue } from 'react-redux';
-import { CreateSelectorFunction } from 'reselect';
-import * as React from 'react';
-import { Context } from 'react';
-
+import { Api, BaseQueryFn, DefinitionType, EndpointDefinitions, InfiniteQueryActionCreatorResult, InfiniteQueryArgFrom, InfiniteQueryDefinition, InfiniteQuerySubState, Module, MutationActionCreatorResult, MutationDefinition, MutationResultSelectorResult, PageParamFrom, PrefetchOptions, QueryActionCreatorResult, QueryArgFrom, QueryDefinition, QueryKeys, QueryStatus, QuerySubState, ResultTypeFrom, SkipToken, SubscriptionOptions, TSHelpersId, TSHelpersOverride, setupListeners } from "@reduxjs/toolkit/query";
+import { CreateSelectorFunction } from "reselect";
+import "@reduxjs/toolkit";
+import "@standard-schema/spec";
+import "redux";
+import "immer";
+import "@standard-schema/utils";
+import * as React from "react";
+import { Context } from "react";
+import { ReactReduxContextValue } from "react-redux";
+export * from "@reduxjs/toolkit/query";
+//#region src/query/core/apiState.d.ts
 type InfiniteData<DataType, PageParam> = {
-    pages: Array<DataType>;
-    pageParams: Array<PageParam>;
+  pages: Array<DataType>;
+  pageParams: Array<PageParam>;
 };
 type InfiniteQueryDirection = 'forward' | 'backward';
-
+//#endregion
+//#region src/query/react/constants.d.ts
 export declare const UNINITIALIZED_VALUE: unique symbol;
 type UninitializedValue = typeof UNINITIALIZED_VALUE;
-
+//#endregion
+//#region src/query/react/buildHooks.d.ts
 type QueryHooks<Definition extends QueryDefinition<any, any, any, any, any>> = {
-    useQuery: UseQuery<Definition>;
-    useLazyQuery: UseLazyQuery<Definition>;
-    useQuerySubscription: UseQuerySubscription<Definition>;
-    useLazyQuerySubscription: UseLazyQuerySubscription<Definition>;
-    useQueryState: UseQueryState<Definition>;
+  useQuery: UseQuery<Definition>;
+  useLazyQuery: UseLazyQuery<Definition>;
+  useQuerySubscription: UseQuerySubscription<Definition>;
+  useLazyQuerySubscription: UseLazyQuerySubscription<Definition>;
+  useQueryState: UseQueryState<Definition>;
 };
 type InfiniteQueryHooks<Definition extends InfiniteQueryDefinition<any, any, any, any, any>> = {
-    useInfiniteQuery: UseInfiniteQuery<Definition>;
-    useInfiniteQuerySubscription: UseInfiniteQuerySubscription<Definition>;
-    useInfiniteQueryState: UseInfiniteQueryState<Definition>;
+  useInfiniteQuery: UseInfiniteQuery<Definition>;
+  useInfiniteQuerySubscription: UseInfiniteQuerySubscription<Definition>;
+  useInfiniteQueryState: UseInfiniteQueryState<Definition>;
 };
 type MutationHooks<Definition extends MutationDefinition<any, any, any, any, any>> = {
-    useMutation: UseMutation<Definition>;
+  useMutation: UseMutation<Definition>;
 };
 /**
  * A React hook that automatically triggers fetches of data from an endpoint, 'subscribes' the component to the cached data, and reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
@@ -55,48 +60,48 @@ type UseQueryHookResult<D extends QueryDefinition<any, any, any, any>, R = UseQu
  */
 type TypedUseQueryHookResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = TypedUseQueryStateResult<ResultType, QueryArg, BaseQuery, R> & TypedUseQuerySubscriptionResult<ResultType, QueryArg, BaseQuery>;
 type UseQuerySubscriptionOptions = SubscriptionOptions & {
-    /**
-     * Prevents a query from automatically running.
-     *
-     * @remarks
-     * When `skip` is true (or `skipToken` is passed in as `arg`):
-     *
-     * - **If the query has cached data:**
-     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
-     *   * The query will have a status of `uninitialized`
-     *   * If `skip: false` is set after the initial load, the cached result will be used
-     * - **If the query does not have cached data:**
-     *   * The query will have a status of `uninitialized`
-     *   * The query will not exist in the state when viewed with the dev tools
-     *   * The query will not automatically fetch on mount
-     *   * The query will not automatically run when additional components with the same query are added that do run
-     *
-     * @example
-     * ```tsx
-     * // codeblock-meta no-transpile title="Skip example"
-     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
-     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
-     *     skip,
-     *   });
-     *
-     *   return (
-     *     <div>
-     *       {name} - {status}
-     *     </div>
-     *   );
-     * };
-     * ```
-     */
-    skip?: boolean;
-    /**
-     * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
-     * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
-     * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
-     * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
-     *
-     * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
-     */
-    refetchOnMountOrArgChange?: boolean | number;
+  /**
+   * Prevents a query from automatically running.
+   *
+   * @remarks
+   * When `skip` is true (or `skipToken` is passed in as `arg`):
+   *
+   * - **If the query has cached data:**
+   *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+   *   * The query will have a status of `uninitialized`
+   *   * If `skip: false` is set after the initial load, the cached result will be used
+   * - **If the query does not have cached data:**
+   *   * The query will have a status of `uninitialized`
+   *   * The query will not exist in the state when viewed with the dev tools
+   *   * The query will not automatically fetch on mount
+   *   * The query will not automatically run when additional components with the same query are added that do run
+   *
+   * @example
+   * ```tsx
+   * // codeblock-meta no-transpile title="Skip example"
+   * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+   *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+   *     skip,
+   *   });
+   *
+   *   return (
+   *     <div>
+   *       {name} - {status}
+   *     </div>
+   *   );
+   * };
+   * ```
+   */
+  skip?: boolean;
+  /**
+   * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
+   * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
+   * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
+   * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
+   *
+   * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+   */
+  refetchOnMountOrArgChange?: boolean | number;
 };
 /**
  * Provides a way to reference the options accepted by the `useQuerySubscription`
@@ -132,7 +137,7 @@ type UseQuerySubscriptionResult<D extends QueryDefinition<any, any, any, any>> =
  */
 type TypedUseQuerySubscriptionResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuerySubscriptionResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
 type UseLazyQueryLastPromiseInfo<D extends QueryDefinition<any, any, any, any>> = {
-    lastArg: QueryArgFrom<D>;
+  lastArg: QueryArgFrom<D>;
 };
 /**
  * A React hook similar to [`useQuery`](#usequery), but with manual control over when the data fetching occurs.
@@ -151,18 +156,14 @@ type UseLazyQueryLastPromiseInfo<D extends QueryDefinition<any, any, any, any>>
  *
  * When the trigger function returned from a LazyQuery is called, it always initiates a new request to the server even if there is cached data. Set `preferCacheValue`(the second argument to the function) as `true` if you want it to immediately return a cached value if one exists.
  */
-type UseLazyQuery<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(options?: SubscriptionOptions & Omit<UseQueryStateOptions<D, R>, 'skip'>) => [
-    LazyQueryTrigger<D>,
-    UseLazyQueryStateResult<D, R>,
-    UseLazyQueryLastPromiseInfo<D>
-];
+type UseLazyQuery<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(options?: SubscriptionOptions & Omit<UseQueryStateOptions<D, R>, 'skip'>) => [LazyQueryTrigger<D>, UseLazyQueryStateResult<D, R>, UseLazyQueryLastPromiseInfo<D>];
 type TypedUseLazyQuery<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseLazyQuery<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
 type UseLazyQueryStateResult<D extends QueryDefinition<any, any, any, any>, R = UseQueryStateDefaultResult<D>> = UseQueryStateResult<D, R> & {
-    /**
-     * Resets the hook state to its initial `uninitialized` state.
-     * This will also remove the last result from the cache.
-     */
-    reset: () => void;
+  /**
+   * Resets the hook state to its initial `uninitialized` state.
+   * This will also remove the last result from the cache.
+   */
+  reset: () => void;
 };
 /**
  * Helper type to manually type the result
@@ -170,27 +171,27 @@ type UseLazyQueryStateResult<D extends QueryDefinition<any, any, any, any>, R =
  */
 type TypedUseLazyQueryStateResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseLazyQueryStateResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>, R>;
 type LazyQueryTrigger<D extends QueryDefinition<any, any, any, any>> = {
-    /**
-     * Triggers a lazy query.
-     *
-     * By default, this will start a new request even if there is already a value in the cache.
-     * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
-     *
-     * @remarks
-     * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
-     *
-     * @example
-     * ```ts
-     * // codeblock-meta title="Using .unwrap with async await"
-     * try {
-     *   const payload = await getUserById(1).unwrap();
-     *   console.log('fulfilled', payload);
-     * } catch (error) {
-     *   console.error('rejected', error);
-     * }
-     * ```
-     */
-    (arg: QueryArgFrom<D>, preferCacheValue?: boolean): QueryActionCreatorResult<D>;
+  /**
+   * Triggers a lazy query.
+   *
+   * By default, this will start a new request even if there is already a value in the cache.
+   * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
+   *
+   * @remarks
+   * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
+   *
+   * @example
+   * ```ts
+   * // codeblock-meta title="Using .unwrap with async await"
+   * try {
+   *   const payload = await getUserById(1).unwrap();
+   *   console.log('fulfilled', payload);
+   * } catch (error) {
+   *   console.error('rejected', error);
+   * }
+   * ```
+   */
+  (arg: QueryArgFrom<D>, preferCacheValue?: boolean): QueryActionCreatorResult<D>;
 };
 type TypedLazyQueryTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = LazyQueryTrigger<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
 /**
@@ -204,13 +205,9 @@ type TypedLazyQueryTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn>
  * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
  * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once
  */
-type UseLazyQuerySubscription<D extends QueryDefinition<any, any, any, any>> = (options?: SubscriptionOptions) => readonly [
-    LazyQueryTrigger<D>,
-    QueryArgFrom<D> | UninitializedValue,
-    {
-        reset: () => void;
-    }
-];
+type UseLazyQuerySubscription<D extends QueryDefinition<any, any, any, any>> = (options?: SubscriptionOptions) => readonly [LazyQueryTrigger<D>, QueryArgFrom<D> | UninitializedValue, {
+  reset: () => void;
+}];
 type TypedUseLazyQuerySubscription<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseLazyQuerySubscription<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
 /**
  * @internal
@@ -322,72 +319,72 @@ type TypedUseQueryState<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = U
  * @internal
  */
 type UseQueryStateOptions<D extends QueryDefinition<any, any, any, any>, R extends Record<string, any>> = {
-    /**
-     * Prevents a query from automatically running.
-     *
-     * @remarks
-     * When skip is true:
-     *
-     * - **If the query has cached data:**
-     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
-     *   * The query will have a status of `uninitialized`
-     *   * If `skip: false` is set after skipping the initial load, the cached result will be used
-     * - **If the query does not have cached data:**
-     *   * The query will have a status of `uninitialized`
-     *   * The query will not exist in the state when viewed with the dev tools
-     *   * The query will not automatically fetch on mount
-     *   * The query will not automatically run when additional components with the same query are added that do run
-     *
-     * @example
-     * ```tsx
-     * // codeblock-meta title="Skip example"
-     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
-     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
-     *     skip,
-     *   });
-     *
-     *   return (
-     *     <div>
-     *       {name} - {status}
-     *     </div>
-     *   );
-     * };
-     * ```
-     */
-    skip?: boolean;
-    /**
-     * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
-     * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
-     * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
-     *
-     * @example
-     * ```tsx
-     * // codeblock-meta title="Using selectFromResult to extract a single result"
-     * function PostsList() {
-     *   const { data: posts } = api.useGetPostsQuery();
-     *
-     *   return (
-     *     <ul>
-     *       {posts?.data?.map((post) => (
-     *         <PostById key={post.id} id={post.id} />
-     *       ))}
-     *     </ul>
-     *   );
-     * }
-     *
-     * function PostById({ id }: { id: number }) {
-     *   // Will select the post with the given id, and will only rerender if the given posts data changes
-     *   const { post } = api.useGetPostsQuery(undefined, {
-     *     selectFromResult: ({ data }) => ({
-     *       post: data?.find((post) => post.id === id),
-     *     }),
-     *   });
-     *
-     *   return <li>{post?.name}</li>;
-     * }
-     * ```
-     */
-    selectFromResult?: QueryStateSelector<R, D>;
+  /**
+   * Prevents a query from automatically running.
+   *
+   * @remarks
+   * When skip is true:
+   *
+   * - **If the query has cached data:**
+   *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+   *   * The query will have a status of `uninitialized`
+   *   * If `skip: false` is set after skipping the initial load, the cached result will be used
+   * - **If the query does not have cached data:**
+   *   * The query will have a status of `uninitialized`
+   *   * The query will not exist in the state when viewed with the dev tools
+   *   * The query will not automatically fetch on mount
+   *   * The query will not automatically run when additional components with the same query are added that do run
+   *
+   * @example
+   * ```tsx
+   * // codeblock-meta title="Skip example"
+   * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+   *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+   *     skip,
+   *   });
+   *
+   *   return (
+   *     <div>
+   *       {name} - {status}
+   *     </div>
+   *   );
+   * };
+   * ```
+   */
+  skip?: boolean;
+  /**
+   * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
+   * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
+   * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
+   *
+   * @example
+   * ```tsx
+   * // codeblock-meta title="Using selectFromResult to extract a single result"
+   * function PostsList() {
+   *   const { data: posts } = api.useGetPostsQuery();
+   *
+   *   return (
+   *     <ul>
+   *       {posts?.map((post) => (
+   *         <PostById key={post.id} id={post.id} />
+   *       ))}
+   *     </ul>
+   *   );
+   * }
+   *
+   * function PostById({ id }: { id: number }) {
+   *   // Will select the post with the given id, and will only rerender if the given posts data changes
+   *   const { post } = api.useGetPostsQuery(undefined, {
+   *     selectFromResult: ({ data }) => ({
+   *       post: data?.find((post) => post.id === id),
+   *     }),
+   *   });
+   *
+   *   return <li>{post?.name}</li>;
+   * }
+   * ```
+   */
+  selectFromResult?: QueryStateSelector<R, D>;
 };
 /**
  * Provides a way to define a "pre-typed" version of
@@ -458,154 +455,154 @@ type UseQueryStateResult<_ extends QueryDefinition<any, any, any, any>, R> = R;
  */
 type TypedUseQueryStateResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = R;
 type UseQueryStateBaseResult<D extends QueryDefinition<any, any, any, any>> = QuerySubState<D> & {
-    /**
-     * Where `data` tries to hold data as much as possible, also reusing
-     * data from the last arguments passed into the hook, this property
-     * will always contain the received data from the query, for the current query arguments.
-     */
-    currentData?: ResultTypeFrom<D>;
-    /**
-     * Query has not started yet.
-     */
-    isUninitialized: false;
-    /**
-     * Query is currently loading for the first time. No data yet.
-     */
-    isLoading: false;
-    /**
-     * Query is currently fetching, but might have data from an earlier request.
-     */
-    isFetching: false;
-    /**
-     * Query has data from a successful load.
-     */
-    isSuccess: false;
-    /**
-     * Query is currently in "error" state.
-     */
-    isError: false;
+  /**
+   * Where `data` tries to hold data as much as possible, also reusing
+   * data from the last arguments passed into the hook, this property
+   * will always contain the received data from the query, for the current query arguments.
+   */
+  currentData?: ResultTypeFrom<D>;
+  /**
+   * Query has not started yet.
+   */
+  isUninitialized: false;
+  /**
+   * Query is currently loading for the first time. No data yet.
+   */
+  isLoading: false;
+  /**
+   * Query is currently fetching, but might have data from an earlier request.
+   */
+  isFetching: false;
+  /**
+   * Query has data from a successful load.
+   */
+  isSuccess: false;
+  /**
+   * Query is currently in "error" state.
+   */
+  isError: false;
 };
 type UseQueryStateUninitialized<D extends QueryDefinition<any, any, any, any>> = TSHelpersOverride<Extract<UseQueryStateBaseResult<D>, {
-    status: QueryStatus.uninitialized;
+  status: QueryStatus.uninitialized;
 }>, {
-    isUninitialized: true;
+  isUninitialized: true;
 }>;
 type UseQueryStateLoading<D extends QueryDefinition<any, any, any, any>> = TSHelpersOverride<UseQueryStateBaseResult<D>, {
-    isLoading: true;
-    isFetching: boolean;
-    data: undefined;
+  isLoading: true;
+  isFetching: boolean;
+  data: undefined;
 }>;
 type UseQueryStateSuccessFetching<D extends QueryDefinition<any, any, any, any>> = TSHelpersOverride<UseQueryStateBaseResult<D>, {
-    isSuccess: true;
-    isFetching: true;
-    error: undefined;
+  isSuccess: true;
+  isFetching: true;
+  error: undefined;
 } & {
-    data: ResultTypeFrom<D>;
+  data: ResultTypeFrom<D>;
 } & Required<Pick<UseQueryStateBaseResult<D>, 'fulfilledTimeStamp'>>>;
 type UseQueryStateSuccessNotFetching<D extends QueryDefinition<any, any, any, any>> = TSHelpersOverride<UseQueryStateBaseResult<D>, {
-    isSuccess: true;
-    isFetching: false;
-    error: undefined;
+  isSuccess: true;
+  isFetching: false;
+  error: undefined;
 } & {
-    data: ResultTypeFrom<D>;
-    currentData: ResultTypeFrom<D>;
+  data: ResultTypeFrom<D>;
+  currentData: ResultTypeFrom<D>;
 } & Required<Pick<UseQueryStateBaseResult<D>, 'fulfilledTimeStamp'>>>;
 type UseQueryStateError<D extends QueryDefinition<any, any, any, any>> = TSHelpersOverride<UseQueryStateBaseResult<D>, {
-    isError: true;
+  isError: true;
 } & Required<Pick<UseQueryStateBaseResult<D>, 'error'>>>;
 type UseQueryStateDefaultResult<D extends QueryDefinition<any, any, any, any>> = TSHelpersId<UseQueryStateUninitialized<D> | UseQueryStateLoading<D> | UseQueryStateSuccessFetching<D> | UseQueryStateSuccessNotFetching<D> | UseQueryStateError<D>> & {
-    /**
-     * @deprecated Included for completeness, but discouraged.
-     * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
-     * and `isUninitialized` flags instead
-     */
-    status: QueryStatus;
+  /**
+   * @deprecated Included for completeness, but discouraged.
+   * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
+   * and `isUninitialized` flags instead
+   */
+  status: QueryStatus;
 };
 type LazyInfiniteQueryTrigger<D extends InfiniteQueryDefinition<any, any, any, any, any>> = {
-    /**
-     * Triggers a lazy query.
-     *
-     * By default, this will start a new request even if there is already a value in the cache.
-     * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
-     *
-     * @remarks
-     * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
-     *
-     * @example
-     * ```ts
-     * // codeblock-meta title="Using .unwrap with async await"
-     * try {
-     *   const payload = await getUserById(1).unwrap();
-     *   console.log('fulfilled', payload);
-     * } catch (error) {
-     *   console.error('rejected', error);
-     * }
-     * ```
-     */
-    (arg: QueryArgFrom<D>, direction: InfiniteQueryDirection): InfiniteQueryActionCreatorResult<D>;
+  /**
+   * Triggers a lazy query.
+   *
+   * By default, this will start a new request even if there is already a value in the cache.
+   * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
+   *
+   * @remarks
+   * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
+   *
+   * @example
+   * ```ts
+   * // codeblock-meta title="Using .unwrap with async await"
+   * try {
+   *   const payload = await getUserById(1).unwrap();
+   *   console.log('fulfilled', payload);
+   * } catch (error) {
+   *   console.error('rejected', error);
+   * }
+   * ```
+   */
+  (arg: QueryArgFrom<D>, direction: InfiniteQueryDirection): InfiniteQueryActionCreatorResult<D>;
 };
 type TypedLazyInfiniteQueryTrigger<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = LazyInfiniteQueryTrigger<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
 type UseInfiniteQuerySubscriptionOptions<D extends InfiniteQueryDefinition<any, any, any, any, any>> = SubscriptionOptions & {
-    /**
-     * Prevents a query from automatically running.
-     *
-     * @remarks
-     * When `skip` is true (or `skipToken` is passed in as `arg`):
-     *
-     * - **If the query has cached data:**
-     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
-     *   * The query will have a status of `uninitialized`
-     *   * If `skip: false` is set after the initial load, the cached result will be used
-     * - **If the query does not have cached data:**
-     *   * The query will have a status of `uninitialized`
-     *   * The query will not exist in the state when viewed with the dev tools
-     *   * The query will not automatically fetch on mount
-     *   * The query will not automatically run when additional components with the same query are added that do run
-     *
-     * @example
-     * ```tsx
-     * // codeblock-meta no-transpile title="Skip example"
-     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
-     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
-     *     skip,
-     *   });
-     *
-     *   return (
-     *     <div>
-     *       {name} - {status}
-     *     </div>
-     *   );
-     * };
-     * ```
-     */
-    skip?: boolean;
-    /**
-     * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
-     * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
-     * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
-     * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
-     *
-     * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
-     */
-    refetchOnMountOrArgChange?: boolean | number;
-    initialPageParam?: PageParamFrom<D>;
-    /**
-     * Defaults to `true`. When this is `true` and an infinite query endpoint is refetched
-     * (due to tag invalidation, polling, arg change configuration, or manual refetching),
-     * RTK Query will try to sequentially refetch all pages currently in the cache.
-     * When `false` only the first page will be refetched.
-     *
-     * This option applies to all automatic refetches for this subscription (polling, tag invalidation, etc.).
-     * It can be overridden on a per-call basis using the `refetch()` method.
-     */
-    refetchCachedPages?: boolean;
+  /**
+   * Prevents a query from automatically running.
+   *
+   * @remarks
+   * When `skip` is true (or `skipToken` is passed in as `arg`):
+   *
+   * - **If the query has cached data:**
+   *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+   *   * The query will have a status of `uninitialized`
+   *   * If `skip: false` is set after the initial load, the cached result will be used
+   * - **If the query does not have cached data:**
+   *   * The query will have a status of `uninitialized`
+   *   * The query will not exist in the state when viewed with the dev tools
+   *   * The query will not automatically fetch on mount
+   *   * The query will not automatically run when additional components with the same query are added that do run
+   *
+   * @example
+   * ```tsx
+   * // codeblock-meta no-transpile title="Skip example"
+   * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+   *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+   *     skip,
+   *   });
+   *
+   *   return (
+   *     <div>
+   *       {name} - {status}
+   *     </div>
+   *   );
+   * };
+   * ```
+   */
+  skip?: boolean;
+  /**
+   * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
+   * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
+   * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
+   * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
+   *
+   * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+   */
+  refetchOnMountOrArgChange?: boolean | number;
+  initialPageParam?: PageParamFrom<D>;
+  /**
+   * Defaults to `true`. When this is `true` and an infinite query endpoint is refetched
+   * (due to tag invalidation, polling, arg change configuration, or manual refetching),
+   * RTK Query will try to sequentially refetch all pages currently in the cache.
+   * When `false` only the first page will be refetched.
+   *
+   * This option applies to all automatic refetches for this subscription (polling, tag invalidation, etc.).
+   * It can be overridden on a per-call basis using the `refetch()` method.
+   */
+  refetchCachedPages?: boolean;
 };
 type TypedUseInfiniteQuerySubscription<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuerySubscription<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
 type UseInfiniteQuerySubscriptionResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = {
-    refetch: (options?: Pick<UseInfiniteQuerySubscriptionOptions<D>, 'refetchCachedPages'>) => InfiniteQueryActionCreatorResult<D>;
-    trigger: LazyInfiniteQueryTrigger<D>;
-    fetchNextPage: () => InfiniteQueryActionCreatorResult<D>;
-    fetchPreviousPage: () => InfiniteQueryActionCreatorResult<D>;
+  refetch: (options?: Pick<UseInfiniteQuerySubscriptionOptions<D>, 'refetchCachedPages'>) => InfiniteQueryActionCreatorResult<D>;
+  trigger: LazyInfiniteQueryTrigger<D>;
+  fetchNextPage: () => InfiniteQueryActionCreatorResult<D>;
+  fetchPreviousPage: () => InfiniteQueryActionCreatorResult<D>;
 };
 /**
  * Helper type to manually type the result
@@ -671,139 +668,141 @@ type UseInfiniteQuerySubscription<D extends InfiniteQueryDefinition<any, any, an
 type UseInfiniteQueryHookResult<D extends InfiniteQueryDefinition<any, any, any, any, any>, R = UseInfiniteQueryStateDefaultResult<D>> = UseInfiniteQueryStateResult<D, R> & Pick<UseInfiniteQuerySubscriptionResult<D>, 'refetch' | 'fetchNextPage' | 'fetchPreviousPage'>;
 type TypedUseInfiniteQueryHookResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryHookResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, R>;
 type UseInfiniteQueryStateOptions<D extends InfiniteQueryDefinition<any, any, any, any, any>, R extends Record<string, any>> = {
-    /**
-     * Prevents a query from automatically running.
-     *
-     * @remarks
-     * When skip is true:
-     *
-     * - **If the query has cached data:**
-     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
-     *   * The query will have a status of `uninitialized`
-     *   * If `skip: false` is set after skipping the initial load, the cached result will be used
-     * - **If the query does not have cached data:**
-     *   * The query will have a status of `uninitialized`
-     *   * The query will not exist in the state when viewed with the dev tools
-     *   * The query will not automatically fetch on mount
-     *   * The query will not automatically run when additional components with the same query are added that do run
-     *
-     * @example
-     * ```tsx
-     * // codeblock-meta title="Skip example"
-     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
-     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
-     *     skip,
-     *   });
-     *
-     *   return (
-     *     <div>
-     *       {name} - {status}
-     *     </div>
-     *   );
-     * };
-     * ```
-     */
-    skip?: boolean;
-    /**
-     * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
-     * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
-     * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
-     * Note that this should always return an object (not a primitive), as RTKQ adds fields to the return value.
-     *
-     * @example
-     * ```tsx
-     * // codeblock-meta title="Using selectFromResult to extract a single result"
-     * function PostsList() {
-     *   const { data: posts } = api.useGetPostsQuery();
-     *
-     *   return (
-     *     <ul>
-     *       {posts?.data?.map((post) => (
-     *         <PostById key={post.id} id={post.id} />
-     *       ))}
-     *     </ul>
-     *   );
-     * }
-     *
-     * function PostById({ id }: { id: number }) {
-     *   // Will select the post with the given id, and will only rerender if the given posts data changes
-     *   const { post } = api.useGetPostsQuery(undefined, {
-     *     selectFromResult: ({ data }) => ({
-     *       post: data?.find((post) => post.id === id),
-     *     }),
-     *   });
-     *
-     *   return <li>{post?.name}</li>;
-     * }
-     * ```
-     */
-    selectFromResult?: InfiniteQueryStateSelector<R, D>;
+  /**
+   * Prevents a query from automatically running.
+   *
+   * @remarks
+   * When skip is true:
+   *
+   * - **If the query has cached data:**
+   *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+   *   * The query will have a status of `uninitialized`
+   *   * If `skip: false` is set after skipping the initial load, the cached result will be used
+   * - **If the query does not have cached data:**
+   *   * The query will have a status of `uninitialized`
+   *   * The query will not exist in the state when viewed with the dev tools
+   *   * The query will not automatically fetch on mount
+   *   * The query will not automatically run when additional components with the same query are added that do run
+   *
+   * @example
+   * ```tsx
+   * // codeblock-meta title="Skip example"
+   * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+   *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+   *     skip,
+   *   });
+   *
+   *   return (
+   *     <div>
+   *       {name} - {status}
+   *     </div>
+   *   );
+   * };
+   * ```
+   */
+  skip?: boolean;
+  /**
+   * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
+   * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
+   * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
+   * Note that this should always return an object (not a primitive), as RTKQ adds fields to the return value.
+   *
+   * @example
+   * ```tsx
+   * // codeblock-meta title="Using selectFromResult to extract a single result"
+   * function PostsList() {
+   *   const { data: posts } = api.useGetPostsQuery();
+   *
+   *   return (
+   *     <ul>
+   *       {posts?.map((post) => (
+   *         <PostById key={post.id} id={post.id} />
+   *       ))}
+   *     </ul>
+   *   );
+   * }
+   *
+   * function PostById({ id }: { id: number }) {
+   *   // Will select the post with the given id, and will only rerender if the given posts data changes
+   *   const { post } = api.useGetPostsQuery(undefined, {
+   *     selectFromResult: ({ data }) => ({
+   *       post: data?.find((post) => post.id === id),
+   *     }),
+   *   });
+   *
+   *   return <li>{post?.name}</li>;
+   * }
+   * ```
+   */
+  selectFromResult?: InfiniteQueryStateSelector<R, D>;
 };
 type TypedUseInfiniteQueryStateOptions<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryStateOptions<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, SelectedResult>;
 type UseInfiniteQueryStateResult<D extends InfiniteQueryDefinition<any, any, any, any, any>, R = UseInfiniteQueryStateDefaultResult<D>> = R;
 type TypedUseInfiniteQueryStateResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, R = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryStateResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, R>;
 type UseInfiniteQueryStateBaseResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = InfiniteQuerySubState<D> & {
-    /**
-     * Where `data` tries to hold data as much as possible, also reusing
-     * data from the last arguments passed into the hook, this property
-     * will always contain the received data from the query, for the current query arguments.
-     */
-    currentData?: InfiniteData<ResultTypeFrom<D>, PageParamFrom<D>>;
-    /**
-     * Query has not started yet.
-     */
-    isUninitialized: false;
-    /**
-     * Query is currently loading for the first time. No data yet.
-     */
-    isLoading: false;
-    /**
-     * Query is currently fetching, but might have data from an earlier request.
-     */
-    isFetching: false;
-    /**
-     * Query has data from a successful load.
-     */
-    isSuccess: false;
-    /**
-     * Query is currently in "error" state.
-     */
-    isError: false;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
-    isFetchingNextPage: boolean;
-    isFetchingPreviousPage: boolean;
+  /**
+   * Where `data` tries to hold data as much as possible, also reusing
+   * data from the last arguments passed into the hook, this property
+   * will always contain the received data from the query, for the current query arguments.
+   */
+  currentData?: InfiniteData<ResultTypeFrom<D>, PageParamFrom<D>>;
+  /**
+   * Query has not started yet.
+   */
+  isUninitialized: false;
+  /**
+   * Query is currently loading for the first time. No data yet.
+   */
+  isLoading: false;
+  /**
+   * Query is currently fetching, but might have data from an earlier request.
+   */
+  isFetching: false;
+  /**
+   * Query has data from a successful load.
+   */
+  isSuccess: false;
+  /**
+   * Query is currently in "error" state.
+   */
+  isError: false;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+  isFetchingNextPage: boolean;
+  isFetchingPreviousPage: boolean;
+  isFetchNextPageError: boolean;
+  isFetchPreviousPageError: boolean;
 };
 type UseInfiniteQueryStateDefaultResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = TSHelpersId<TSHelpersOverride<Extract<UseInfiniteQueryStateBaseResult<D>, {
-    status: QueryStatus.uninitialized;
+  status: QueryStatus.uninitialized;
 }>, {
-    isUninitialized: true;
+  isUninitialized: true;
 }> | TSHelpersOverride<UseInfiniteQueryStateBaseResult<D>, {
-    isLoading: true;
-    isFetching: boolean;
-    data: undefined;
+  isLoading: true;
+  isFetching: boolean;
+  data: undefined;
 } | ({
-    isSuccess: true;
-    isFetching: true;
-    error: undefined;
+  isSuccess: true;
+  isFetching: true;
+  error: undefined;
 } & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp'>>) | ({
-    isSuccess: true;
-    isFetching: false;
-    error: undefined;
+  isSuccess: true;
+  isFetching: false;
+  error: undefined;
 } & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp' | 'currentData'>>) | ({
-    isError: true;
+  isError: true;
 } & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'error'>>)>> & {
-    /**
-     * @deprecated Included for completeness, but discouraged.
-     * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
-     * and `isUninitialized` flags instead
-     */
-    status: QueryStatus;
+  /**
+   * @deprecated Included for completeness, but discouraged.
+   * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
+   * and `isUninitialized` flags instead
+   */
+  status: QueryStatus;
 };
 type MutationStateSelector<R extends Record<string, any>, D extends MutationDefinition<any, any, any, any>> = (state: MutationResultSelectorResult<D>) => R;
 type UseMutationStateOptions<D extends MutationDefinition<any, any, any, any>, R extends Record<string, any>> = {
-    selectFromResult?: MutationStateSelector<R, D>;
-    fixedCacheKey?: string;
+  selectFromResult?: MutationStateSelector<R, D>;
+  fixedCacheKey?: string;
 };
 /**
  * Provides a way to define a "pre-typed" version of
@@ -819,12 +818,12 @@ type UseMutationStateOptions<D extends MutationDefinition<any, any, any, any>, R
  */
 type TypedUseMutationStateOptions<ResultType, QueryArg, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = MutationResultSelectorResult<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseMutationStateOptions<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>, SelectedResult>;
 type UseMutationStateResult<D extends MutationDefinition<any, any, any, any>, R> = R & {
-    originalArgs?: QueryArgFrom<D>;
-    /**
-     * Resets the hook state to its initial `uninitialized` state.
-     * This will also remove the last result from the cache.
-     */
-    reset: () => void;
+  originalArgs?: QueryArgFrom<D>;
+  /**
+   * Resets the hook state to its initial `uninitialized` state.
+   * This will also remove the last result from the cache.
+   */
+  reset: () => void;
 };
 /**
  * Helper type to manually type the result
@@ -844,112 +843,104 @@ type TypedUseMutationResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn,
 type UseMutation<D extends MutationDefinition<any, any, any, any>> = <R extends Record<string, any> = MutationResultSelectorResult<D>>(options?: UseMutationStateOptions<D, R>) => readonly [MutationTrigger<D>, UseMutationStateResult<D, R>];
 type TypedUseMutation<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseMutation<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
 type MutationTrigger<D extends MutationDefinition<any, any, any, any>> = {
-    /**
-     * Triggers the mutation and returns a Promise.
-     * @remarks
-     * If you need to access the error or success payload immediately after a mutation, you can chain .unwrap().
-     *
-     * @example
-     * ```ts
-     * // codeblock-meta title="Using .unwrap with async await"
-     * try {
-     *   const payload = await addPost({ id: 1, name: 'Example' }).unwrap();
-     *   console.log('fulfilled', payload);
-     * } catch (error) {
-     *   console.error('rejected', error);
-     * }
-     * ```
-     */
-    (arg: QueryArgFrom<D>): MutationActionCreatorResult<D>;
+  /**
+   * Triggers the mutation and returns a Promise.
+   * @remarks
+   * If you need to access the error or success payload immediately after a mutation, you can chain .unwrap().
+   *
+   * @example
+   * ```ts
+   * // codeblock-meta title="Using .unwrap with async await"
+   * try {
+   *   const payload = await addPost({ id: 1, name: 'Example' }).unwrap();
+   *   console.log('fulfilled', payload);
+   * } catch (error) {
+   *   console.error('rejected', error);
+   * }
+   * ```
+   */
+  (arg: QueryArgFrom<D>): MutationActionCreatorResult<D>;
 };
 type TypedMutationTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = MutationTrigger<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
-
-type QueryHookNames<Definitions extends EndpointDefinitions> = {
-    [K in keyof Definitions as Definitions[K] extends {
-        type: DefinitionType.query;
-    } ? `use${Capitalize<K & string>}Query` : never]: UseQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>;
-};
-type LazyQueryHookNames<Definitions extends EndpointDefinitions> = {
-    [K in keyof Definitions as Definitions[K] extends {
-        type: DefinitionType.query;
-    } ? `useLazy${Capitalize<K & string>}Query` : never]: UseLazyQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>;
-};
-type InfiniteQueryHookNames<Definitions extends EndpointDefinitions> = {
-    [K in keyof Definitions as Definitions[K] extends {
-        type: DefinitionType.infinitequery;
-    } ? `use${Capitalize<K & string>}InfiniteQuery` : never]: UseInfiniteQuery<Extract<Definitions[K], InfiniteQueryDefinition<any, any, any, any, any>>>;
-};
-type MutationHookNames<Definitions extends EndpointDefinitions> = {
-    [K in keyof Definitions as Definitions[K] extends {
-        type: DefinitionType.mutation;
-    } ? `use${Capitalize<K & string>}Mutation` : never]: UseMutation<Extract<Definitions[K], MutationDefinition<any, any, any, any>>>;
-};
+//#endregion
+//#region src/query/react/namedHooks.d.ts
+type QueryHookNames<Definitions extends EndpointDefinitions> = { [K in keyof Definitions as Definitions[K] extends {
+  type: DefinitionType.query;
+} ? `use${Capitalize<K & string>}Query` : never]: UseQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>; };
+type LazyQueryHookNames<Definitions extends EndpointDefinitions> = { [K in keyof Definitions as Definitions[K] extends {
+  type: DefinitionType.query;
+} ? `useLazy${Capitalize<K & string>}Query` : never]: UseLazyQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>; };
+type InfiniteQueryHookNames<Definitions extends EndpointDefinitions> = { [K in keyof Definitions as Definitions[K] extends {
+  type: DefinitionType.infinitequery;
+} ? `use${Capitalize<K & string>}InfiniteQuery` : never]: UseInfiniteQuery<Extract<Definitions[K], InfiniteQueryDefinition<any, any, any, any, any>>>; };
+type MutationHookNames<Definitions extends EndpointDefinitions> = { [K in keyof Definitions as Definitions[K] extends {
+  type: DefinitionType.mutation;
+} ? `use${Capitalize<K & string>}Mutation` : never]: UseMutation<Extract<Definitions[K], MutationDefinition<any, any, any, any>>>; };
 type HooksWithUniqueNames<Definitions extends EndpointDefinitions> = QueryHookNames<Definitions> & LazyQueryHookNames<Definitions> & InfiniteQueryHookNames<Definitions> & MutationHookNames<Definitions>;
-
+//#endregion
+//#region src/query/react/module.d.ts
 export declare const reactHooksModuleName: unique symbol;
 type ReactHooksModule = typeof reactHooksModuleName;
 declare module '@reduxjs/toolkit/query' {
-    interface ApiModules<BaseQuery extends BaseQueryFn, Definitions extends EndpointDefinitions, ReducerPath extends string, TagTypes extends string> {
-        [reactHooksModuleName]: {
-            /**
-             *  Endpoints based on the input endpoints provided to `createApi`, containing `select`, `hooks` and `action matchers`.
-             */
-            endpoints: {
-                [K in keyof Definitions]: Definitions[K] extends QueryDefinition<any, any, any, any, any> ? QueryHooks<Definitions[K]> : Definitions[K] extends MutationDefinition<any, any, any, any, any> ? MutationHooks<Definitions[K]> : Definitions[K] extends InfiniteQueryDefinition<any, any, any, any, any> ? InfiniteQueryHooks<Definitions[K]> : never;
-            };
-            /**
-             * A hook that accepts a string endpoint name, and provides a callback that when called, pre-fetches the data for that endpoint.
-             */
-            usePrefetch<EndpointName extends QueryKeys<Definitions>>(endpointName: EndpointName, options?: PrefetchOptions): (arg: QueryArgFrom<Definitions[EndpointName]>, options?: PrefetchOptions) => void;
-        } & HooksWithUniqueNames<Definitions>;
-    }
+  interface ApiModules<BaseQuery extends BaseQueryFn, Definitions extends EndpointDefinitions, ReducerPath extends string, TagTypes extends string> {
+    [reactHooksModuleName]: {
+      /**
+       *  Endpoints based on the input endpoints provided to `createApi`, containing `select`, `hooks` and `action matchers`.
+       */
+      endpoints: { [K in keyof Definitions]: Definitions[K] extends QueryDefinition<any, any, any, any, any> ? QueryHooks<Definitions[K]> : Definitions[K] extends MutationDefinition<any, any, any, any, any> ? MutationHooks<Definitions[K]> : Definitions[K] extends InfiniteQueryDefinition<any, any, any, any, any> ? InfiniteQueryHooks<Definitions[K]> : never; };
+      /**
+       * A hook that accepts a string endpoint name, and provides a callback that when called, pre-fetches the data for that endpoint.
+       */
+      usePrefetch<EndpointName extends QueryKeys<Definitions>>(endpointName: EndpointName, options?: PrefetchOptions): (arg: QueryArgFrom<Definitions[EndpointName]>, options?: PrefetchOptions) => void;
+    } & HooksWithUniqueNames<Definitions>;
+  }
 }
-type RR = typeof react_redux;
+type RR = typeof import('react-redux');
 interface ReactHooksModuleOptions {
-    /**
-     * The hooks from React Redux to be used
-     */
-    hooks?: {
-        /**
-         * The version of the `useDispatch` hook to be used
-         */
-        useDispatch: RR['useDispatch'];
-        /**
-         * The version of the `useSelector` hook to be used
-         */
-        useSelector: RR['useSelector'];
-        /**
-         * The version of the `useStore` hook to be used
-         */
-        useStore: RR['useStore'];
-    };
-    /**
-     * The version of the `batchedUpdates` function to be used
-     */
-    batch?: RR['batch'];
-    /**
-     * Enables performing asynchronous tasks immediately within a render.
-     *
-     * @example
-     *
-     * ```ts
-     * import {
-     *   buildCreateApi,
-     *   coreModule,
-     *   reactHooksModule
-     * } from '@reduxjs/toolkit/query/react'
-     *
-     * const createApi = buildCreateApi(
-     *   coreModule(),
-     *   reactHooksModule({ unstable__sideEffectsInRender: true })
-     * )
-     * ```
-     */
-    unstable__sideEffectsInRender?: boolean;
-    /**
-     * A selector creator (usually from `reselect`, or matching the same signature)
-     */
-    createSelector?: CreateSelectorFunction<any, any, any>;
+  /**
+   * The hooks from React Redux to be used
+   */
+  hooks?: {
+    /**
+     * The version of the `useDispatch` hook to be used
+     */
+    useDispatch: RR['useDispatch'];
+    /**
+     * The version of the `useSelector` hook to be used
+     */
+    useSelector: RR['useSelector'];
+    /**
+     * The version of the `useStore` hook to be used
+     */
+    useStore: RR['useStore'];
+  };
+  /**
+   * The version of the `batchedUpdates` function to be used
+   */
+  batch?: RR['batch'];
+  /**
+   * Enables performing asynchronous tasks immediately within a render.
+   *
+   * @example
+   *
+   * ```ts
+   * import {
+   *   buildCreateApi,
+   *   coreModule,
+   *   reactHooksModule
+   * } from '@reduxjs/toolkit/query/react'
+   *
+   * const createApi = buildCreateApi(
+   *   coreModule(),
+   *   reactHooksModule({ unstable__sideEffectsInRender: true })
+   * )
+   * ```
+   */
+  unstable__sideEffectsInRender?: boolean;
+  /**
+   * A selector creator (usually from `reselect`, or matching the same signature)
+   */
+  createSelector?: CreateSelectorFunction<any, any, any>;
 }
 /**
  * Creates a module that generates react hooks from endpoints, for use with `buildCreateApi`.
@@ -972,7 +963,8 @@ interface ReactHooksModuleOptions {
  * @returns A module for use with `buildCreateApi`
  */
 declare const reactHooksModule: ({ batch, hooks, createSelector, unstable__sideEffectsInRender, ...rest }?: ReactHooksModuleOptions) => Module<ReactHooksModule>;
-
+//#endregion
+//#region src/query/react/ApiProvider.d.ts
 /**
  * Can be used as a `Provider` if you **do not already have a Redux store**.
  *
@@ -998,12 +990,13 @@ declare const reactHooksModule: ({ batch, hooks, createSelector, unstable__sideE
  * in that case.
  */
 declare function ApiProvider(props: {
-    children: any;
-    api: Api<any, {}, any, any>;
-    setupListeners?: Parameters<typeof setupListeners>[1] | false;
-    context?: Context<ReactReduxContextValue | null>;
+  children: any;
+  api: Api<any, {}, any, any>;
+  setupListeners?: Parameters<typeof setupListeners>[1] | false;
+  context?: Context<ReactReduxContextValue | null>;
 }): React.JSX.Element;
-
-declare const createApi: _reduxjs_toolkit_query.CreateApi<typeof _reduxjs_toolkit_query.coreModuleName | typeof reactHooksModuleName>;
-
+//#endregion
+//#region src/query/react/index.d.ts
+declare const createApi: import("@reduxjs/toolkit/query").CreateApi<typeof import("@reduxjs/toolkit/query").coreModuleName | typeof reactHooksModuleName>;
+//#endregion
 export { ApiProvider, type TypedInfiniteQueryStateSelector, type TypedLazyInfiniteQueryTrigger, type TypedLazyQueryTrigger, type TypedMutationTrigger, type TypedQueryStateSelector, type TypedUseInfiniteQuery, type TypedUseInfiniteQueryHookResult, type TypedUseInfiniteQueryState, type TypedUseInfiniteQueryStateOptions, type TypedUseInfiniteQueryStateResult, type TypedUseInfiniteQuerySubscription, type TypedUseInfiniteQuerySubscriptionResult, type TypedUseLazyQuery, type TypedUseLazyQueryStateResult, type TypedUseLazyQuerySubscription, type TypedUseMutation, type TypedUseMutationResult, type TypedUseMutationStateOptions, type TypedUseQuery, type TypedUseQueryHookResult, type TypedUseQueryState, type TypedUseQueryStateOptions, type TypedUseQueryStateResult, type TypedUseQuerySubscription, type TypedUseQuerySubscriptionOptions, type TypedUseQuerySubscriptionResult, createApi, reactHooksModule };