@openapi-qraft/react 1.14.0-beta.5 → 2.0.0-next.0

package/src/qraftAPIClient.ts

@@ -1,21 +1,78 @@
-import type { Context } from 'react';
+import type { QueryClient } from '@tanstack/query-core';
+import type * as callbacks from './callbacks/index.js';
 import type * as operationInvokeModule from './callbacks/operationInvokeFn.js';
-import type { OperationSchema } from './lib/requestFn.js';
-import type { QraftContextValue } from './QraftContext.js';
+import type {
+  OperationSchema,
+  RequestFnInfo,
+  RequestFnResponse,
+} from './lib/requestFn.js';
+import type {
+  ServiceOperationMutation,
+  ServiceOperationQuery,
+} from './service-operation/index.js';
+import type { ServiceOperationMutationFn } from './service-operation/ServiceOperationMutationFn.js';
+import type { ServiceOperationQueryFn } from './service-operation/ServiceOperationQueryFn.js';
 import { createRecursiveProxy } from './lib/createRecursiveProxy.js';
 
-export interface QraftClientOptions {
-  context?: Context<QraftContextValue>;
+export interface CreateAPIBasicClientOptions {
+  requestFn<TData, TError>(
+    schema: OperationSchema,
+    requestInfo: RequestFnInfo
+  ): Promise<RequestFnResponse<TData, TError>>;
+  baseUrl: string;
 }
 
-export const qraftAPIClient = <
-  Services extends ServicesBaseDeclaration<Services>,
-  Callbacks extends ServicesCallbacks,
+export interface CreateAPIQueryClientOptions
+  extends CreateAPIBasicClientOptions {
+  queryClient: QueryClient;
+}
+
+/**
+ * @deprecated use `CreateAPIClientOptions` instead
+ */
+export type QraftClientOptions =
+  | CreateAPIBasicClientOptions
+  | CreateAPIQueryClientOptions;
+
+export type CreateAPIClientOptions =
+  | CreateAPIBasicClientOptions
+  | CreateAPIQueryClientOptions;
+
+export function qraftAPIClient<
+  Services extends ServicesDeclaration<Services>,
+  TCallbacks extends Callbacks,
+>(
+  services: ServiceSchemasDeclaration<Services>,
+  callbacks: TCallbacks,
+  options: CreateAPIBasicClientOptions
+): APIBasicClientServices<Services, TCallbacks>;
+
+export function qraftAPIClient<
+  Services extends ServicesDeclaration<Services>,
+  TCallbacks extends Required<Callbacks>,
 >(
-  services: ServicesDeclaration<Services>,
-  callbacks: Callbacks,
-  options?: QraftClientOptions
-): Services => {
+  services: ServiceSchemasDeclaration<Services>,
+  callbacks: TCallbacks,
+  options: CreateAPIQueryClientOptions
+): Services;
+
+export function qraftAPIClient<
+  Services extends ServicesDeclaration<Services>,
+  TCallbacks extends Callbacks,
+>(
+  services: ServiceSchemasDeclaration<Services>,
+  callbacks: TCallbacks,
+  options: CreateAPIQueryClientOptions
+): APIQueryClientServices<Services, TCallbacks>;
+
+export function qraftAPIClient<
+  Services extends ServicesDeclaration<Services>,
+  TCallbacks extends Callbacks,
+>(
+  services: ServiceSchemasDeclaration<Services>,
+  callbacks: TCallbacks,
+  options: CreateAPIClientOptions
+): APIQueryClientServices<Services, TCallbacks> | Services {
   return createRecursiveProxy(
     function getCallback(getPath, key) {
       if (getPath.length !== 2 || key !== 'schema') return; // todo::maybe return callback?
@@ -28,23 +85,46 @@ export const qraftAPIClient = <
     function applyCallback(applyPath, args) {
       const { path, callbackName } = extractCallbackDetails(applyPath);
 
-      if (!(callbackName in callbacks))
-        throw new Error(`Function ${callbackName} is not supported`);
+      assertValidCallbackName(callbackName, callbacks);
 
       const serviceOperation = getByPath(services, path);
 
       if (!isServiceOperation(serviceOperation))
         throw new Error(`Service operation not found: ${path.join('.')}`);
 
-      return callbacks[callbackName as keyof Callbacks](
-        options,
-        serviceOperation.schema,
-        args
-      );
+      if (
+        callbackName !== 'operationInvokeFn' &&
+        callbackName !== 'getQueryKey' &&
+        callbackName !== 'getMutationKey'
+      )
+        if (!('queryClient' in options && options.queryClient))
+          throw new Error(
+            `'qraft.<service>.<operation>.${String(callbackName)}()' requires 'queryClient' in options.`
+          );
+
+      // @ts-expect-error - Too complex union type
+      return callbacks[callbackName](options, serviceOperation.schema, args);
     },
     []
   ) as never;
-};
+}
+
+function assertValidCallbackName<
+  TCallbacks extends Record<string, (...rest: any[]) => unknown>,
+>(
+  callbackName: string | number | symbol,
+  callbacks: TCallbacks
+): asserts callbackName is keyof TCallbacks {
+  if (!(callbackName in callbacks)) {
+    if ((callbackName as OperationInvokeFnName) === 'operationInvokeFn')
+      throw new Error(
+        `Callback 'operationInvokeFn' is required for executing 'qraft.<service>.<operation>()', but it is not provided in the 'callbacks' object.`
+      );
+    throw new Error(
+      `Callback for 'qraft.<service>.<operation>.${String(callbackName)}()' is not provided in the 'callbacks' object.`
+    );
+  }
+}
 
 /**
  * Extracts Callback details from the applyPath
@@ -55,10 +135,7 @@ function extractCallbackDetails(applyPath: string[]) {
   if (applyPath.length === 2) {
     return {
       path: applyPath,
-      callbackName: 'operationInvokeFn' satisfies Extract<
-        keyof typeof operationInvokeModule,
-        'operationInvokeFn'
-      >,
+      callbackName: 'operationInvokeFn' satisfies OperationInvokeFnName,
     };
   } else {
     // <service>.<operation>.<method>()
@@ -83,18 +160,146 @@ function getByPath(obj: Record<string, unknown>, path: string[]) {
   }, obj);
 }
 
-type ServicesBaseDeclaration<Services> = {
+type Callbacks = Partial<typeof callbacks>;
+
+type ServicesDeclaration<Services> = {
   [service in keyof Services]: {
-    [method in keyof Services[service]]: { schema: OperationSchema };
+    [method in keyof Services[service]]: {
+      schema: OperationSchema;
+      types: {
+        parameters?: any;
+        data?: any;
+        error?: any;
+        body?: any;
+      };
+    };
   };
 };
 
-type ServicesDeclaration<Services extends ServicesBaseDeclaration<Services>> = {
-  [service in keyof Services]: {
-    [method in keyof Services[service]]: {
-      schema: Services[service][method]['schema'];
+type ServiceSchemasDeclaration<Services extends ServicesDeclaration<Services>> =
+  {
+    [service in keyof Services]: {
+      [method in keyof Services[service]]: {
+        schema: Services[service][method]['schema'];
+      };
     };
   };
+
+type QueryOperationCallbacks = Extract<
+  keyof Callbacks,
+  | 'cancelQueries'
+  | 'fetchInfiniteQuery'
+  | 'fetchQuery'
+  | 'getInfiniteQueryData'
+  | 'getInfiniteQueryKey'
+  | 'getInfiniteQueryState'
+  | 'getQueriesData'
+  | 'getQueryData'
+  | 'getQueryKey'
+  | 'getQueryState'
+  | 'invalidateQueries'
+  | 'isFetching'
+  | 'prefetchInfiniteQuery'
+  | 'prefetchQuery'
+  | 'refetchQueries'
+  | 'removeQueries'
+  | 'resetQueries'
+  | 'setInfiniteQueryData'
+  | 'setQueriesData'
+  | 'setQueryData'
+  | 'useInfiniteQuery'
+  | 'useIsFetching'
+  | 'useQueries'
+  | 'useQuery'
+  | 'useSuspenseInfiniteQuery'
+  | 'useSuspenseQueries'
+  | 'useSuspenseQuery'
+>;
+
+type MutationOperationCallbacks = Extract<
+  keyof Callbacks,
+  | 'getMutationKey'
+  | 'isMutating'
+  | 'useIsMutating'
+  | 'useMutation'
+  | 'useMutationState'
+>;
+
+export type APIQueryClientServices<
+  TServices extends ServicesDeclaration<TServices>,
+  TCallbacks extends Callbacks,
+> = ServicesFilteredByCallbacks<
+  TServices,
+  TCallbacks,
+  QueryOperationCallbacks,
+  MutationOperationCallbacks
+>;
+
+export type APIBasicClientServices<
+  TServices extends ServicesDeclaration<TServices>,
+  TCallbacks extends Callbacks,
+> = ServicesFilteredByCallbacks<
+  TServices,
+  TCallbacks,
+  Extract<QueryOperationCallbacks, 'getQueryKey'>,
+  Extract<MutationOperationCallbacks, 'getMutationKey'>
+>;
+
+type ServicesFilteredByCallbacks<
+  TServices extends ServicesDeclaration<TServices>,
+  TCallbacks extends Callbacks,
+  TQueryOperationCallbacks extends QueryOperationCallbacks,
+  TMutationOperationCallbacks extends MutationOperationCallbacks,
+> = {
+  [serviceName in keyof TServices]: {
+    [method in keyof TServices[serviceName]]: TServices[serviceName][method]['schema']['method'] extends
+      | 'get'
+      | 'head'
+      | 'options'
+      ? Pick<
+          ServiceOperationQuery<
+            TServices[serviceName][method]['schema'],
+            TServices[serviceName][method]['types']['data'],
+            TServices[serviceName][method]['types']['parameters'],
+            TServices[serviceName][method]['types']['error']
+          >,
+          | Extract<keyof TCallbacks, TQueryOperationCallbacks>
+          | 'types'
+          | 'schema'
+        > &
+          (OperationInvokeFnName extends keyof TCallbacks
+            ? ServiceOperationQueryFn<
+                TServices[serviceName][method]['schema'],
+                TServices[serviceName][method]['types']['data'],
+                TServices[serviceName][method]['types']['parameters'],
+                TServices[serviceName][method]['types']['error']
+              >
+            : {})
+      : Pick<
+          ServiceOperationMutation<
+            TServices[serviceName][method]['schema'],
+            TServices[serviceName][method]['types']['body'],
+            TServices[serviceName][method]['types']['data'],
+            TServices[serviceName][method]['types']['parameters'],
+            TServices[serviceName][method]['types']['error']
+          >,
+          | Extract<keyof TCallbacks, TMutationOperationCallbacks>
+          | 'types'
+          | 'schema'
+        > &
+          (OperationInvokeFnName extends keyof TCallbacks
+            ? ServiceOperationMutationFn<
+                TServices[serviceName][method]['schema'],
+                TServices[serviceName][method]['types']['body'],
+                TServices[serviceName][method]['types']['data'],
+                TServices[serviceName][method]['types']['parameters'],
+                TServices[serviceName][method]['types']['error']
+              >
+            : {});
+  };
 };
 
-type ServicesCallbacks = Record<string, (...rest: any[]) => unknown>;
+type OperationInvokeFnName = Extract<
+  keyof typeof operationInvokeModule,
+  'operationInvokeFn'
+>;

package/src/service-operation/ServiceOperation.ts

@@ -40,7 +40,7 @@ export interface ServiceOperationQuery<
     ServiceOperationUseSuspenseQuery<TSchema, TData, TParams, TError>,
     ServiceOperationUseSuspenseInfiniteQuery<TSchema, TData, TParams, TError>,
     ServiceOperationUseIsFetchingQueries<TSchema, TData, TParams, TError>,
-    ServiceOperationQueryFn<TSchema, TData, TParams>,
+    ServiceOperationQueryFn<TSchema, TData, TParams, TError>,
     ServiceOperationFetchQuery<TSchema, TData, TParams, TError>,
     ServiceOperationFetchInfiniteQuery<TSchema, TData, TParams, TError>,
     ServiceOperationGetQueryData<TSchema, TData, TParams>,
@@ -74,7 +74,7 @@ export interface ServiceOperationMutation<
     ServiceOperationUseIsMutating<TSchema, TBody, TData, TParams, TError>,
     ServiceOperationUseMutationState<TSchema, TBody, TData, TParams, TError>,
     ServiceOperationIsMutatingQueries<TSchema, TBody, TData, TParams, TError>,
-    ServiceOperationMutationFn<TSchema, TBody, TData, TParams> {
+    ServiceOperationMutationFn<TSchema, TBody, TData, TParams, TError> {
   schema: TSchema;
   types: {
     parameters: TParams;

package/src/service-operation/ServiceOperationCancelQueries.ts

@@ -1,8 +1,4 @@
-import type {
-  CancelOptions,
-  DefaultError,
-  QueryClient,
-} from '@tanstack/query-core';
+import type { CancelOptions, DefaultError } from '@tanstack/query-core';
 import type {
   QueryFiltersByParameters,
   QueryFiltersByQueryKey,
@@ -14,39 +10,10 @@ export interface ServiceOperationCancelQueries<
   TParams = {},
   TError = DefaultError,
 > {
-  cancelQueries<TInfinite extends boolean>(
-    filters:
+  cancelQueries<TInfinite extends boolean = false>(
+    filters?:
       | QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError>
       | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>,
-    options: CancelOptions,
-    queryClient: QueryClient
-  ): Promise<void>;
-
-  cancelQueries<TInfinite extends boolean>(
-    filters:
-      | QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError>
-      | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>,
-    queryClient: QueryClient
-  ): Promise<void>;
-
-  cancelQueries(queryClient: QueryClient): Promise<void>;
-}
-
-/**
- * @internal
- */
-export interface ServiceOperationCancelQueriesCallback<
-  TSchema extends { url: string; method: string },
-  TData,
-  TParams = {},
-  TError = DefaultError,
-> extends ServiceOperationCancelQueries<TSchema, TData, TParams, TError> {
-  cancelQueries<TInfinite extends boolean>(
-    filters:
-      | QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError>
-      | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>
-      | QueryClient,
-    options?: CancelOptions | QueryClient,
-    queryClient?: QueryClient
+    options?: CancelOptions
   ): Promise<void>;
 }

package/src/service-operation/ServiceOperationFetchInfiniteQuery.ts

@@ -3,7 +3,6 @@ import type {
   FetchQueryOptions,
   GetNextPageParamFunction,
   InitialPageParam,
-  QueryClient,
   QueryFunction,
 } from '@tanstack/query-core';
 import type { PartialParameters } from '../lib/PartialParameters.type.js';
@@ -29,7 +28,7 @@ export interface ServiceOperationFetchInfiniteQuery<
           TPageParam,
           TError
         > &
-          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>)
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams, TError>)
       | (FetchInfiniteQueryOptionsByParameters<
           TSchema,
           TData,
@@ -37,8 +36,7 @@ export interface ServiceOperationFetchInfiniteQuery<
           TPageParam,
           TError
         > &
-          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>),
-    queryClient: QueryClient
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams, TError>)
   ): Promise<OperationInfiniteData<TData, TParams>>;
 
   prefetchInfiniteQuery<TPageParam extends TParams>(
@@ -50,7 +48,7 @@ export interface ServiceOperationFetchInfiniteQuery<
           TPageParam,
           TError
         > &
-          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>)
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams, TError>)
       | (FetchInfiniteQueryOptionsByParameters<
           TSchema,
           TData,
@@ -58,8 +56,7 @@ export interface ServiceOperationFetchInfiniteQuery<
           TPageParam,
           TError
         > &
-          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams>),
-    queryClient: QueryClient
+          FetchInfiniteQueryOptionsQueryFn<TSchema, TData, TParams, TError>)
   ): Promise<void>;
 }
 
@@ -136,20 +133,24 @@ type FetchInfiniteQueryOptionsByParameters<
 type FetchInfiniteQueryOptionsQueryFn<
   TSchema extends { url: string; method: string },
   TData,
-  TParams = {},
+  TParams,
+  TError,
 > =
   | {
-      queryFn?: QueryFunction<
+      queryFn: QueryFunction<
         TData,
         ServiceOperationInfiniteQueryKey<TSchema, TParams>
       >;
     }
   | {
-      requestFn: RequestFn<TData>;
+      /**
+       * Custom request function to use for the query
+       */
+      requestFn?: RequestFn<TData, TError>;
       /**
        * Base URL to use for the request (used in the `queryFn`)
        * @example 'https://api.example.com'
        */
-      baseUrl: string | undefined;
+      baseUrl?: string | undefined;
       queryFn?: never; // Workaround to fix union type error
     };

package/src/service-operation/ServiceOperationFetchQuery.ts

@@ -1,37 +1,52 @@
 import type {
   DefaultError,
   FetchQueryOptions,
-  QueryClient,
   QueryFunction,
 } from '@tanstack/query-core';
 import type { RequestFn } from '../lib/requestFn.js';
 import type { ServiceOperationQueryKey } from './ServiceOperationKey.js';
+import { AreAllOptional } from '../lib/AreAllOptional.js';
 
 export interface ServiceOperationFetchQuery<
   TSchema extends { url: string; method: string },
   TData,
-  TParams = {},
+  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
+    options: AreAllOptional<TParams> extends true
+      ? ServiceOperationFetchQueryOptions<
+          TSchema,
+          TData,
+          TParams,
+          TError
+        > | void
+      : ServiceOperationFetchQueryOptions<TSchema, TData, TParams, TError>
   ): Promise<TData>;
 
   prefetchQuery(
-    options:
-      | (FetchQueryOptionsByQueryKey<TSchema, TData, TParams, TError> &
-          FetchQueryOptionsQueryFn<TSchema, TData, TParams>)
-      | (FetchQueryOptionsByParameters<TSchema, TData, TParams, TError> &
-          FetchQueryOptionsQueryFn<TSchema, TData, TParams>),
-    queryClient: QueryClient
+    options: AreAllOptional<TParams> extends true
+      ? ServiceOperationFetchQueryOptions<
+          TSchema,
+          TData,
+          TParams,
+          TError
+        > | void
+      : ServiceOperationFetchQueryOptions<TSchema, TData, TParams, TError>
   ): Promise<void>;
 }
 
+type ServiceOperationFetchQueryOptions<
+  TSchema extends { url: string; method: string },
+  TData,
+  TParams,
+  TError,
+> =
+  | (FetchQueryOptionsByQueryKey<TSchema, TData, TParams, TError> &
+      FetchQueryOptionsQueryFn<TSchema, TData, TParams, TError>)
+  | (FetchQueryOptionsByParameters<TSchema, TData, TParams, TError> &
+      FetchQueryOptionsQueryFn<TSchema, TData, TParams, TError>);
+
 type FetchQueryOptionsBase<
   TSchema extends { url: string; method: string },
   TData,
@@ -56,7 +71,8 @@ interface FetchQueryOptionsByQueryKey<
   /**
    * Fetch Queries by query key
    */
-  queryKey?: ServiceOperationQueryKey<TSchema, TParams>;
+  queryKey: ServiceOperationQueryKey<TSchema, TParams>;
+  parameters?: never;
 }
 
 interface FetchQueryOptionsByParameters<
@@ -68,27 +84,28 @@ interface FetchQueryOptionsByParameters<
   /**
    * Fetch Queries by parameters
    */
-  parameters?: TParams;
+  parameters: TParams;
   queryKey?: never;
 }
 
 type FetchQueryOptionsQueryFn<
   TSchema extends { url: string; method: string },
   TData,
-  TParams = {},
+  TParams,
+  TError,
 > =
   | {
-      queryFn?: QueryFunction<
-        TData,
-        ServiceOperationQueryKey<TSchema, TParams>
-      >;
+      queryFn: QueryFunction<TData, ServiceOperationQueryKey<TSchema, TParams>>;
     }
   | {
-      requestFn: RequestFn<TData>;
+      /**
+       * Custom request function to use for the query
+       */
+      requestFn?: RequestFn<TData, TError>;
       /**
        * Base URL to use for the request (used in the `queryFn`)
        * @example 'https://api.example.com'
        */
-      baseUrl: string | undefined;
+      baseUrl?: string | undefined;
       queryFn?: never; // Workaround to fix union type error
     };

package/src/service-operation/ServiceOperationGetInfiniteQueryData.ts

@@ -1,14 +1,15 @@
-import type { QueryClient } from '@tanstack/query-core';
+import type { AreAllOptional } from '../lib/AreAllOptional.js';
 import type { OperationInfiniteData } from './OperationInfiniteData.js';
 import type { ServiceOperationInfiniteQueryKey } from './ServiceOperationKey.js';
 
 export interface ServiceOperationGetInfiniteQueryData<
   TSchema extends { url: string; method: string },
   TData,
-  TParams = {},
+  TParams,
 > {
   getInfiniteQueryData(
-    parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>,
-    queryClient: QueryClient
+    parameters: AreAllOptional<TParams> extends true
+      ? TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams> | void
+      : TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>
   ): OperationInfiniteData<TData, TParams> | undefined;
 }

package/src/service-operation/ServiceOperationGetQueriesData.ts

@@ -1,4 +1,4 @@
-import type { DefaultError, NoInfer, QueryClient } from '@tanstack/query-core';
+import type { DefaultError, NoInfer } from '@tanstack/query-core';
 import type { OperationInfiniteData } from './OperationInfiniteData.js';
 import type {
   QueryFiltersByParameters,
@@ -12,14 +12,13 @@ import type {
 export interface ServiceOperationGetQueriesData<
   TSchema extends { url: string; method: string },
   TData,
-  TParams = {}, // todo::try to replace `TParams = {}` with `TParams = undefined`
+  TParams,
   TError = DefaultError,
 > {
-  getQueriesData<TInfinite extends boolean>(
-    filters:
+  getQueriesData<TInfinite extends boolean = false>(
+    filters?:
       | QueryFiltersByParameters<TSchema, TData, TInfinite, TParams, TError>
-      | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>,
-    queryClient: QueryClient
+      | QueryFiltersByQueryKey<TSchema, TData, TInfinite, TParams, TError>
   ): TInfinite extends true
     ? Array<
         [

package/src/service-operation/ServiceOperationGetQueryData.ts

@@ -1,13 +1,14 @@
-import type { QueryClient } from '@tanstack/query-core';
+import type { AreAllOptional } from '../lib/AreAllOptional.js';
 import type { ServiceOperationQueryKey } from './ServiceOperationKey.js';
 
 export interface ServiceOperationGetQueryData<
   TSchema extends { url: string; method: string },
   TData,
-  TParams = {},
+  TParams,
 > {
   getQueryData(
-    parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>,
-    queryClient: QueryClient
+    parameters: AreAllOptional<TParams> extends true
+      ? TParams | ServiceOperationQueryKey<TSchema, TParams> | void
+      : TParams | ServiceOperationQueryKey<TSchema, TParams>
   ): TData | undefined;
 }

package/src/service-operation/ServiceOperationGetQueryState.ts

@@ -1,8 +1,4 @@
-import type {
-  DefaultError,
-  QueryClient,
-  QueryState,
-} from '@tanstack/query-core';
+import type { DefaultError, QueryState } from '@tanstack/query-core';
 import type { OperationInfiniteData } from './OperationInfiniteData.js';
 import type {
   ServiceOperationInfiniteQueryKey,
@@ -16,12 +12,10 @@ export interface ServiceOperationGetQueryState<
   TError = DefaultError,
 > {
   getQueryState(
-    parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>,
-    queryClient: QueryClient
+    parameters: TParams | ServiceOperationQueryKey<TSchema, TParams>
   ): QueryState<TData, TError> | undefined;
 
   getInfiniteQueryState(
-    parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>,
-    queryClient: QueryClient
+    parameters: TParams | ServiceOperationInfiniteQueryKey<TSchema, TParams>
   ): QueryState<OperationInfiniteData<TData, TParams>, TError> | undefined;
 }