@openapi-qraft/react 1.1.5 → 1.3.2

package/src/ServiceOperation.ts

@@ -12,10 +12,14 @@ import {
   QueriesPlaceholderDataFunction,
   Query,
   QueryClient,
+  FetchQueryOptions,
   RefetchOptions,
   ResetOptions,
   SetDataOptions,
   Updater,
+  QueryFunction,
+  InitialPageParam,
+  GetNextPageParamFunction,
 } from '@tanstack/query-core';
 import type {
   DefinedInitialDataInfiniteOptions,
@@ -35,6 +39,8 @@ import type {
   UseSuspenseQueryResult,
 } from '@tanstack/react-query';
 
+import type { RequestFn } from './lib/requestFn.js';
+
 export type ServiceOperationQueryKey<
   S extends { url: string; method: string },
   T,
@@ -63,6 +69,8 @@ export interface ServiceOperationQuery<
     ServiceOperationUseSuspenseInfiniteQuery<TSchema, TData, TParams, TError>,
     ServiceOperationUseIsFetchingQueries<TSchema, TData, TParams, TError>,
     ServiceOperationQueryFn<TSchema, TData, TParams>,
+    ServiceOperationFetchQuery<TSchema, TData, TParams, TError>,
+    ServiceOperationFetchInfiniteQuery<TSchema, TData, TParams, TError>,
     ServiceOperationGetQueryData<TSchema, TData, TParams>,
     ServiceOperationGetInfiniteQueryData<TSchema, TData, TParams>,
     ServiceOperationSetQueryData<TSchema, TData, TParams>,
@@ -118,6 +126,232 @@ interface ServiceOperationUseQuery<
   ): DefinedUseQueryResult<TData, TError | Error>;
 }
 
+type FetchQueryOptionsBase<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> = Omit<
+  FetchQueryOptions<
+    TData,
+    TError,
+    TData,
+    ServiceOperationQueryKey<TSchema, TParams>
+  >,
+  'queryKey' | 'queryFn'
+>;
+
+interface FetchQueryOptionsByQueryKey<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> extends FetchQueryOptionsBase<TSchema, TData, TParams, TError> {
+  /**
+   * Fetch Queries by query key
+   */
+  queryKey?: ServiceOperationQueryKey<TSchema, TParams>;
+}
+
+interface FetchQueryOptionsByParameters<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> extends FetchQueryOptionsBase<TSchema, TData, TParams, TError> {
+  /**
+   * Fetch Queries by parameters
+   */
+  parameters?: TParams;
+  queryKey?: never;
+}
+
+type FetchQueryOptionsQueryFn<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+> =
+  | {
+      queryFn?: QueryFunction<
+        TData,
+        ServiceOperationQueryKey<TSchema, TParams>
+      >;
+    }
+  | {
+      requestFn: RequestFn<TData>;
+      /**
+       * Base URL to use for the request (used in the `queryFn`)
+       * @example 'https://api.example.com'
+       */
+      baseUrl: string | undefined;
+      queryFn?: never; // Workaround to fix union type error
+    };
+
+interface ServiceOperationFetchQuery<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> {
+  fetchQuery(
+    options:
+      | (FetchQueryOptionsByQueryKey<TSchema, TData, TParams, TError> &
+          FetchQueryOptionsQueryFn<TSchema, TData, TParams>)
+      | (FetchQueryOptionsByParameters<TSchema, TData, TParams, TError> &
+          FetchQueryOptionsQueryFn<TSchema, TData, TParams>),
+    queryClient: QueryClient
+  ): Promise<TData>;
+  prefetchQuery(
+    options:
+      | (FetchQueryOptionsByQueryKey<TSchema, TData, TParams, TError> &
+          FetchQueryOptionsQueryFn<TSchema, TData, TParams>)
+      | (FetchQueryOptionsByParameters<TSchema, TData, TParams, TError> &
+          FetchQueryOptionsQueryFn<TSchema, TData, TParams>),
+    queryClient: QueryClient
+  ): Promise<void>;
+}
+
+type FetchInfiniteQueryOptionsBase<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TPageParam = unknown,
+  TError = DefaultError,
+> = Omit<
+  FetchQueryOptions<
+    TData,
+    TError,
+    InfiniteData<TData, TPageParam>,
+    ServiceOperationQueryKey<TSchema, TParams>,
+    TPageParam
+  >,
+  'queryKey'
+> &
+  InitialPageParam<PartialParameters<TPageParam>> &
+  FetchInfiniteQueryPages<TData, TPageParam>;
+
+type FetchInfiniteQueryPages<TData = unknown, TPageParam = unknown> =
+  | {
+      pages?: never;
+    }
+  | {
+      pages: number;
+      getNextPageParam: GetNextPageParamFunction<
+        PartialParameters<TPageParam>,
+        TData
+      >;
+    };
+
+type FetchInfiniteQueryOptionsByQueryKey<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TPageParam = {},
+  TError = DefaultError,
+> = FetchInfiniteQueryOptionsBase<
+  TSchema,
+  TData,
+  TParams,
+  TPageParam,
+  TError
+> & {
+  /**
+   * Fetch Queries by query key
+   */
+  queryKey?: ServiceOperationInfiniteQueryKey<TSchema, TParams>;
+  parameters?: never;
+};
+
+type FetchInfiniteQueryOptionsByParameters<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TPageParam = {},
+  TError = DefaultError,
+> = FetchInfiniteQueryOptionsBase<
+  TSchema,
+  TData,
+  TParams,
+  TPageParam,
+  TError
+> & {
+  /**
+   * Fetch Queries by parameters
+   */
+  parameters?: TParams;
+  queryKey?: never;
+};
+
+type FetchInfiniteQueryOptionsQueryFn<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+> =
+  | {
+      queryFn?: QueryFunction<
+        TData,
+        ServiceOperationInfiniteQueryKey<TSchema, TParams>
+      >;
+    }
+  | {
+      requestFn: RequestFn<TData>;
+      /**
+       * Base URL to use for the request (used in the `queryFn`)
+       * @example 'https://api.example.com'
+       */
+      baseUrl: string | undefined;
+      queryFn?: never; // Workaround to fix union type error
+    };
+
+interface ServiceOperationFetchInfiniteQuery<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+  TError = DefaultError,
+> {
+  fetchInfiniteQuery<TPageParam extends TParams>(
+    options:
+      | (FetchInfiniteQueryOptionsByQueryKey<
+          TSchema,
+          TData,
+          TParams,
+          TPageParam,
+          TError
+        > &
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>)
+      | (FetchInfiniteQueryOptionsByParameters<
+          TSchema,
+          TData,
+          TParams,
+          TPageParam,
+          TError
+        > &
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>),
+    queryClient: QueryClient
+  ): Promise<InfiniteData<TData, TPageParam>>;
+
+  prefetchInfiniteQuery<TPageParam extends TParams>(
+    options:
+      | (FetchInfiniteQueryOptionsByQueryKey<
+          TSchema,
+          TData,
+          TParams,
+          TPageParam,
+          TError
+        > &
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>)
+      | (FetchInfiniteQueryOptionsByParameters<
+          TSchema,
+          TData,
+          TParams,
+          TPageParam,
+          TError
+        > &
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>),
+    queryClient: QueryClient
+  ): Promise<void>;
+}
+
 interface ServiceOperationUseQueries<
   TSchema extends { url: string; method: string },
   TData,
@@ -138,7 +372,7 @@ interface ServiceOperationUseQueries<
         > & {
           placeholderData?: TData | QueriesPlaceholderDataFunction<TData>;
         } & (
-            | { parameters: TParams }
+            | { parameters: TParams; queryKey?: never }
             | { queryKey: ServiceOperationQueryKey<TSchema, TParams> }
           )
       >;
@@ -452,7 +686,7 @@ interface ServiceOperationUseSuspenseQueries<
           'queryKey'
         > &
           (
-            | { parameters: TParams }
+            | { parameters: TParams; queryKey?: never }
             | { queryKey: ServiceOperationQueryKey<TSchema, TParams> }
           )
       >;
@@ -736,6 +970,7 @@ interface QueryFnOptionsByParameters<
   TSignal extends AbortSignal = AbortSignal,
 > extends QueryFnOptionsBase<TMeta, TSignal> {
   parameters: TParams;
+  queryKey?: never;
 }
 
 interface QueryFnOptionsByQueryKey<
@@ -795,8 +1030,30 @@ interface ServiceOperationSetQueryData<
   setQueryData(
     parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>,
     updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>,
-    queryClient: QueryClient,
-    options?: SetDataOptions
+    options: SetDataOptions,
+    queryClient: QueryClient
+  ): TData | undefined;
+
+  setQueryData(
+    parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>,
+    updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>,
+    queryClient: QueryClient
+  ): TData | undefined;
+}
+
+/**
+ * @internal
+ */
+export interface ServiceOperationSetQueryDataCallback<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams = {},
+> extends ServiceOperationSetQueryData<TSchema, TData, TParams> {
+  setQueryData(
+    parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>,
+    updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>,
+    options: SetDataOptions | QueryClient,
+    queryClient?: QueryClient
   ): TData | undefined;
 }
 

package/src/callbacks/cancelQueries.ts

@@ -1,14 +1,14 @@
 import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import { ServiceOperationCancelQueriesCallback } from '../ServiceOperation.js';
 
 export function cancelQueries<TData>(
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationCancelQueriesCallback<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       TData
     >['cancelQueries']

package/src/callbacks/fetchInfiniteQuery.ts

@@ -0,0 +1,22 @@
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientFetchMethod.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export const fetchInfiniteQuery: <
+  TSchema extends { url: string; method: 'get' | 'head' | 'options' },
+  TData,
+  TParams,
+>(
+  _: QraftClientOptions | undefined,
+  schema: TSchema,
+  args: Parameters<
+    ServiceOperationQuery<TSchema, TData, TParams>['fetchInfiniteQuery']
+  >
+) => Promise<TData> = (_, schema, args) => {
+  return callQueryClientMethodWithQueryKey(
+    'fetchInfiniteQuery',
+    schema,
+    true,
+    args as never
+  ) as never;
+};

package/src/callbacks/fetchQuery.ts

@@ -0,0 +1,20 @@
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientFetchMethod.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export const fetchQuery: <
+  TSchema extends { url: string; method: 'get' | 'head' | 'options' },
+  TData,
+  TParams,
+>(
+  _: QraftClientOptions | undefined,
+  schema: TSchema,
+  args: Parameters<ServiceOperationQuery<TSchema, TData, TParams>['fetchQuery']>
+) => Promise<TData> = (_, schema, args) => {
+  return callQueryClientMethodWithQueryKey(
+    'fetchQuery',
+    schema,
+    false,
+    args as never
+  ) as never;
+};

package/src/callbacks/getInfiniteQueryData.ts

@@ -1,28 +1,25 @@
-import { InfiniteData } from '@tanstack/query-core';
+import type { InfiniteData } from '@tanstack/query-core';
 
-import { composeInfiniteQueryKey } from '../lib/composeInfiniteQueryKey.js';
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientMethodWithQueryKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
-import {
-  ServiceOperationInfiniteQueryKey,
-  ServiceOperationQuery,
-} from '../ServiceOperation.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export function getInfiniteQueryData<TData>(
-  qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationQuery<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       TData
     >['getInfiniteQueryData']
   >
 ): InfiniteData<TData> | undefined {
-  const [parameters, queryClient] = args;
-  return queryClient.getQueryData(
-    Array.isArray(parameters)
-      ? parameters
-      : composeInfiniteQueryKey(schema, parameters)
-  );
+  return callQueryClientMethodWithQueryKey(
+    'getQueryData',
+    schema,
+    true,
+    args as never
+  ) as never;
 }

package/src/callbacks/getInfiniteQueryKey.ts

@@ -1,14 +1,14 @@
 import { composeInfiniteQueryKey } from '../lib/composeInfiniteQueryKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export const getInfiniteQueryKey = (
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationQuery<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       unknown
     >['getInfiniteQueryKey']

package/src/callbacks/getMutationKey.ts

@@ -1,14 +1,14 @@
 import { composeMutationKey } from '../lib/composeMutationKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import { ServiceOperationMutation } from '../ServiceOperation.js';
 
 export const getMutationKey = (
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationMutation<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       unknown,
       unknown

package/src/callbacks/getQueryData.ts

@@ -1,17 +1,19 @@
-import { composeQueryKey } from '../lib/composeQueryKey.js';
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientMethodWithQueryKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
-import { ServiceOperationQuery } from '../ServiceOperation.js';
+import type { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export function getQueryData<TData>(
-  qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  _: QraftClientOptions | undefined,
+  schema: OperationSchema,
   args: Parameters<
-    ServiceOperationQuery<RequestClientSchema, unknown, TData>['getQueryData']
+    ServiceOperationQuery<OperationSchema, unknown, TData>['getQueryData']
   >
 ): TData | undefined {
-  const [parameters, queryClient] = args;
-  return queryClient.getQueryData(
-    Array.isArray(parameters) ? parameters : composeQueryKey(schema, parameters)
-  );
+  return callQueryClientMethodWithQueryKey(
+    'getQueryData',
+    schema,
+    false,
+    args as never
+  ) as never;
 }

package/src/callbacks/getQueryKey.ts

@@ -1,13 +1,13 @@
 import { composeQueryKey } from '../lib/composeQueryKey.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import { ServiceOperationQuery } from '../ServiceOperation.js';
 
 export const getQueryKey = (
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
-    ServiceOperationQuery<RequestClientSchema, unknown, unknown>['getQueryKey']
+    ServiceOperationQuery<OperationSchema, unknown, unknown>['getQueryKey']
   >
 ) => {
   return composeQueryKey(schema, args[0]);

package/src/callbacks/invalidateQueries.ts

@@ -1,14 +1,14 @@
 import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import type { ServiceOperationInvalidateQueriesCallback } from '../ServiceOperation.js';
 
 export function invalidateQueries<TData>(
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationInvalidateQueriesCallback<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       TData
     >['invalidateQueries']

package/src/callbacks/isFetching.ts

@@ -1,14 +1,14 @@
 import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import { ServiceOperationIsFetchingQueriesCallback } from '../ServiceOperation.js';
 
 export function isFetching<TData>(
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationIsFetchingQueriesCallback<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       TData
     >['isFetching']

package/src/callbacks/mutationFn.ts

@@ -1,15 +1,15 @@
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import { ServiceOperationMutation } from '../ServiceOperation.js';
 
 export const mutationFn = (
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: unknown
 ) => {
   const [client, options] = args as Parameters<
     ServiceOperationMutation<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       unknown,
       never

package/src/callbacks/prefetchInfiniteQuery.ts

@@ -0,0 +1,22 @@
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientFetchMethod.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export const prefetchInfiniteQuery: <
+  TSchema extends { url: string; method: 'get' | 'head' | 'options' },
+  TData,
+  TParams,
+>(
+  _: QraftClientOptions | undefined,
+  schema: TSchema,
+  args: Parameters<
+    ServiceOperationQuery<TSchema, TData, TParams>['prefetchInfiniteQuery']
+  >
+) => Promise<TData> = (_, schema, args) => {
+  return callQueryClientMethodWithQueryKey(
+    'prefetchInfiniteQuery',
+    schema,
+    true,
+    args as never
+  ) as never;
+};

package/src/callbacks/prefetchQuery.ts

@@ -0,0 +1,22 @@
+import { callQueryClientMethodWithQueryKey } from '../lib/callQueryClientFetchMethod.js';
+import type { QraftClientOptions } from '../qraftAPIClient.js';
+import { ServiceOperationQuery } from '../ServiceOperation.js';
+
+export const prefetchQuery: <
+  TSchema extends { url: string; method: 'get' | 'head' | 'options' },
+  TData,
+  TParams,
+>(
+  _: QraftClientOptions | undefined,
+  schema: TSchema,
+  args: Parameters<
+    ServiceOperationQuery<TSchema, TData, TParams>['prefetchQuery']
+  >
+) => Promise<TData> = (_, schema, args) => {
+  return callQueryClientMethodWithQueryKey(
+    'prefetchQuery',
+    schema,
+    false,
+    args as never
+  ) as never;
+};

package/src/callbacks/queryFn.ts

@@ -12,9 +12,9 @@ export const queryFn: <
 ) => Promise<TData> = (_, schema, args) => {
   const [options, client] = args;
 
-  return client('queryKey' in options ? options.queryKey[0] : schema, {
+  return client('queryKey' in options ? options.queryKey![0] : schema, {
     parameters:
-      'queryKey' in options ? options.queryKey[1] : options.parameters,
+      'queryKey' in options ? options.queryKey![1] : options.parameters,
     meta: options.meta,
     signal: options.signal,
   }) as Promise<never>;

package/src/callbacks/refetchQueries.ts

@@ -1,14 +1,14 @@
 import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
-import { ServiceOperationResetQueriesCallback } from '../ServiceOperation.js';
+import type { ServiceOperationResetQueriesCallback } from '../ServiceOperation.js';
 
 export function refetchQueries<TData>(
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationResetQueriesCallback<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       TData
     >['refetchQueries']

package/src/callbacks/resetQueries.ts

@@ -1,14 +1,14 @@
 import { callQueryClientMethodWithQueryFilters } from '../lib/callQueryClientMethodWithQueryFilters.js';
+import type { OperationSchema } from '../lib/requestFn.js';
 import type { QraftClientOptions } from '../qraftAPIClient.js';
-import type { RequestClientSchema } from '../RequestClient.js';
 import type { ServiceOperationResetQueriesCallback } from '../ServiceOperation.js';
 
 export function resetQueries<TData>(
   qraftOptions: QraftClientOptions | undefined,
-  schema: RequestClientSchema,
+  schema: OperationSchema,
   args: Parameters<
     ServiceOperationResetQueriesCallback<
-      RequestClientSchema,
+      OperationSchema,
       unknown,
       TData
     >['resetQueries']