@kubb/plugin-svelte-query 3.0.0-beta.8 → 3.0.0

package/src/components/QueryOptions.tsx

@@ -14,20 +14,59 @@ type Props = {
   clientName: string
   queryKeyName: string
   typeSchemas: OperationSchemas
+  paramsType: PluginSvelteQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
 }
 
 type GetParamsProps = {
+  paramsType: PluginSvelteQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps) {
+  if (paramsType === 'object') {
+    return FunctionParams.factory({
+      data: {
+        mode: 'object',
+        children: {
+          ...getPathParams(typeSchemas.pathParams, { typed: true }),
+          data: typeSchemas.request?.name
+            ? {
+                type: typeSchemas.request?.name,
+                optional: isOptional(typeSchemas.request?.schema),
+              }
+            : undefined,
+          params: typeSchemas.queryParams?.name
+            ? {
+                type: typeSchemas.queryParams?.name,
+                optional: isOptional(typeSchemas.queryParams?.schema),
+              }
+            : undefined,
+          headers: typeSchemas.headerParams?.name
+            ? {
+                type: typeSchemas.headerParams?.name,
+                optional: isOptional(typeSchemas.headerParams?.schema),
+              }
+            : undefined,
+        },
+      },
+      config: {
+        type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>',
+        default: '{}',
+      },
+    })
+  }
+
   return FunctionParams.factory({
-    pathParams: {
-      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-      children: getPathParams(typeSchemas.pathParams, { typed: true }),
-    },
+    pathParams: typeSchemas.pathParams?.name
+      ? {
+          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
+          children: getPathParams(typeSchemas.pathParams, { typed: true }),
+          type: typeSchemas.pathParams?.name,
+          optional: isOptional(typeSchemas.pathParams?.schema),
+        }
+      : undefined,
     data: typeSchemas.request?.name
       ? {
           type: typeSchemas.request?.name,
@@ -53,9 +92,10 @@ function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
   })
 }
 
-export function QueryOptions({ name, clientName, typeSchemas, pathParamsType, queryKeyName }: Props): ReactNode {
-  const params = getParams({ pathParamsType, typeSchemas })
+export function QueryOptions({ name, clientName, typeSchemas, paramsType, pathParamsType, queryKeyName }: Props): ReactNode {
+  const params = getParams({ paramsType, pathParamsType, typeSchemas })
   const clientParams = Client.getParams({
+    paramsType,
     typeSchemas,
     pathParamsType,
   })

package/src/generators/__snapshots__/clientDataReturnTypeFull.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig, ResponseConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
-import { createQuery, queryOptions } from "@tanstack/svelte-query";
+import { queryOptions, createQuery } from "@tanstack/svelte-query";
 
  export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 

package/src/generators/__snapshots__/clientGetImportPath.ts

@@ -1,7 +1,7 @@
 import client from "axios";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
 import type { RequestConfig } from "axios";
-import { createQuery, queryOptions } from "@tanstack/svelte-query";
+import { queryOptions, createQuery } from "@tanstack/svelte-query";
 
  export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 

package/src/generators/__snapshots__/findByTags.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
-import { createQuery, queryOptions } from "@tanstack/svelte-query";
+import { queryOptions, createQuery } from "@tanstack/svelte-query";
 
  export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 

package/src/generators/__snapshots__/findByTagsObject.ts

@@ -0,0 +1,60 @@
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
+import { queryOptions, createQuery } from "@tanstack/svelte-query";
+
+ export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
+
+ export type FindPetsByTagsQueryKey = ReturnType<typeof findPetsByTagsQueryKey>;
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+async function findPetsByTags({ headers, params }: {
+    headers: FindPetsByTagsHeaderParams;
+    params?: FindPetsByTagsQueryParams;
+}, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, headers: { ...headers, ...config.headers }, ...config });
+    return findPetsByTagsQueryResponse.parse(res.data);
+}
+
+ export function findPetsByTagsQueryOptions({ headers, params }: {
+    headers: FindPetsByTagsHeaderParams;
+    params?: FindPetsByTagsQueryParams;
+}, config: Partial<RequestConfig> = {}) {
+    const queryKey = findPetsByTagsQueryKey(params);
+    return queryOptions({
+        queryKey,
+        queryFn: async ({ signal }) => {
+            config.signal = signal;
+            return findPetsByTags({ headers, params }, config);
+        },
+    });
+}
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export function createFindPetsByTags<TData = FindPetsByTagsQueryResponse, TQueryData = FindPetsByTagsQueryResponse, TQueryKey extends QueryKey = FindPetsByTagsQueryKey>({ headers, params }: {
+    headers: FindPetsByTagsHeaderParams;
+    params?: FindPetsByTagsQueryParams;
+}, options: {
+    query?: Partial<CreateBaseQueryOptions<FindPetsByTagsQueryResponse, FindPetsByTags400, TData, TQueryData, TQueryKey>>;
+    client?: Partial<RequestConfig>;
+} = {}) {
+    const { query: queryOptions, client: config = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? findPetsByTagsQueryKey(params);
+    const query = createQuery({
+        ...findPetsByTagsQueryOptions({ headers, params }, config) as unknown as CreateBaseQueryOptions,
+        queryKey,
+        ...queryOptions as unknown as Omit<CreateBaseQueryOptions, "queryKey">
+    }) as CreateQueryResult<TData, FindPetsByTags400> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/generators/__snapshots__/findByTagsPathParamsObject.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
-import { createQuery, queryOptions } from "@tanstack/svelte-query";
+import { queryOptions, createQuery } from "@tanstack/svelte-query";
 
  export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 

package/src/generators/__snapshots__/findByTagsWithCustomQueryKey.ts

@@ -1,9 +1,9 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/react-query";
-import { createQuery, queryOptions } from "@tanstack/react-query";
+import { queryOptions, createQuery } from "@tanstack/react-query";
 
- export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [test, { url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
+ export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => ["test", { url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 
  export type FindPetsByTagsQueryKey = ReturnType<typeof findPetsByTagsQueryKey>;
 

package/src/generators/__snapshots__/findByTagsWithZod.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
-import { createQuery, queryOptions } from "@tanstack/svelte-query";
+import { queryOptions, createQuery } from "@tanstack/svelte-query";
 
  export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 

package/src/generators/__snapshots__/postAsQuery.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "custom-query";
-import { createQuery, queryOptions } from "custom-query";
+import { queryOptions, createQuery } from "custom-query";
 
  export const updatePetWithFormQueryKey = (petId: UpdatePetWithFormPathParams["petId"], data?: UpdatePetWithFormMutationRequest, params?: UpdatePetWithFormQueryParams) => [{ url: "/pet/:petId", params: { petId: petId } }, ...(params ? [params] : []), ...(data ? [data] : [])] as const;
 

package/src/generators/__snapshots__/updatePetByIdPathParamsObject.ts

@@ -11,9 +11,7 @@ import { createMutation } from "@tanstack/svelte-query";
  * @summary Updates a pet in the store with form data
  * @link /pet/:petId
  */
-async function updatePetWithForm({ petId }: {
-    petId: UpdatePetWithFormPathParams["petId"];
-}, data?: UpdatePetWithFormMutationRequest, params?: UpdatePetWithFormQueryParams, config: Partial<RequestConfig<UpdatePetWithFormMutationRequest>> = {}) {
+async function updatePetWithForm({ petId }: UpdatePetWithFormPathParams, data?: UpdatePetWithFormMutationRequest, params?: UpdatePetWithFormQueryParams, config: Partial<RequestConfig<UpdatePetWithFormMutationRequest>> = {}) {
     const res = await client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationRequest>({ method: "POST", url: `/pet/${petId}`, params, data, ...config });
     return updatePetWithFormMutationResponse.parse(res.data);
 }

package/src/generators/mutationGenerator.tsx

@@ -1,4 +1,3 @@
-import transformers from '@kubb/core/transformers'
 import { pluginClientName } from '@kubb/plugin-client'
 import { Client } from '@kubb/plugin-client/components'
 import { createReactGenerator } from '@kubb/plugin-oas'
@@ -22,6 +21,8 @@ export const mutationGenerator = createReactGenerator<PluginSvelteQuery>({
     const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
     const isMutation = !isQuery && options.mutation && options.mutation.methods.some((method) => operation.method === method)
 
+    const importPath = options.mutation ? options.mutation.importPath : '@tanstack/svelte-query'
+
     const mutation = {
       name: getName(operation, { type: 'function', prefix: 'create' }),
       typeName: getName(operation, { type: 'type' }),
@@ -48,15 +49,14 @@ export const mutationGenerator = createReactGenerator<PluginSvelteQuery>({
       typeName: getName(operation, { type: 'type', suffix: 'MutationKey' }),
     }
 
-    if (!isMutation || typeof options.mutation === 'boolean') {
+    if (!isMutation) {
       return null
     }
 
     return (
       <File baseName={mutation.file.baseName} path={mutation.file.path} meta={mutation.file.meta} banner={output?.banner} footer={output?.footer}>
         {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={mutation.file.path} path={zod.file.path} />}
-        <File.Import name={['createMutation']} path={options.mutation.importPath} />
-        <File.Import name={['CreateMutationOptions', 'CreateMutationResult']} path={options.mutation.importPath} isTypeOnly />
+
         <File.Import name={'client'} path={options.client.importPath} />
         <File.Import name={['RequestConfig', 'ResponseConfig']} path={options.client.importPath} isTypeOnly />
         <File.Import
@@ -72,36 +72,45 @@ export const mutationGenerator = createReactGenerator<PluginSvelteQuery>({
           path={type.file.path}
           isTypeOnly
         />
+
         <MutationKey
           name={mutationKey.name}
           typeName={mutationKey.typeName}
           operation={operation}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
-          keysFn={options.mutation.key}
+          transformer={options.mutationKey}
         />
         <Client
           name={client.name}
           isExportable={false}
           isIndexable={false}
-          baseURL={options.baseURL}
+          baseURL={options.client.baseURL}
           operation={operation}
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
-        <Mutation
-          name={mutation.name}
-          clientName={client.name}
-          typeName={mutation.typeName}
-          typeSchemas={type.schemas}
-          operation={operation}
-          dataReturnType={options.client.dataReturnType}
-          pathParamsType={options.pathParamsType}
-          mutationKeyName={mutationKey.name}
-        />
+        {options.mutation && (
+          <>
+            <File.Import name={['createMutation']} path={importPath} />
+            <File.Import name={['CreateMutationOptions', 'CreateMutationResult']} path={importPath} isTypeOnly />
+            <Mutation
+              name={mutation.name}
+              clientName={client.name}
+              typeName={mutation.typeName}
+              typeSchemas={type.schemas}
+              operation={operation}
+              dataReturnType={options.client.dataReturnType}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              mutationKeyName={mutationKey.name}
+            />
+          </>
+        )}
       </File>
     )
   },

package/src/generators/queryGenerator.tsx

@@ -1,4 +1,3 @@
-import transformers from '@kubb/core/transformers'
 import { pluginClientName } from '@kubb/plugin-client'
 import { Client } from '@kubb/plugin-client/components'
 import { createReactGenerator } from '@kubb/plugin-oas'
@@ -20,7 +19,7 @@ export const queryGenerator = createReactGenerator<PluginSvelteQuery>({
     const { getSchemas, getName, getFile } = useOperationManager()
 
     const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
-    const isMutation = !isQuery && options.mutation && options.mutation.methods.some((method) => operation.method === method)
+    const importPath = options.query ? options.query.importPath : '@tanstack/svelte-query'
 
     const query = {
       name: getName(operation, { type: 'function', prefix: 'create' }),
@@ -52,15 +51,13 @@ export const queryGenerator = createReactGenerator<PluginSvelteQuery>({
       schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
     }
 
-    if (!isQuery || typeof options.query === 'boolean') {
+    if (!isQuery) {
       return null
     }
 
     return (
       <File baseName={query.file.baseName} path={query.file.path} meta={query.file.meta} banner={output?.banner} footer={output?.footer}>
         {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={query.file.path} path={zod.file.path} />}
-        <File.Import name={['createQuery', 'queryOptions']} path={options.query.importPath} />
-        <File.Import name={['QueryKey', 'WithRequired', 'CreateBaseQueryOptions', 'CreateQueryResult']} path={options.query.importPath} isTypeOnly />
         <File.Import name={'client'} path={options.client.importPath} />
         <File.Import name={['RequestConfig']} path={options.client.importPath} isTypeOnly />
         {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
@@ -84,37 +81,48 @@ export const queryGenerator = createReactGenerator<PluginSvelteQuery>({
           operation={operation}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
-          keysFn={options.query.key}
+          transformer={options.queryKey}
         />
+
         <Client
           name={client.name}
           isExportable={false}
           isIndexable={false}
-          baseURL={options.baseURL}
+          baseURL={options.client.baseURL}
           operation={operation}
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
+        <File.Import name={['queryOptions']} path={importPath} />
         <QueryOptions
           name={queryOptions.name}
           clientName={client.name}
           queryKeyName={queryKey.name}
           typeSchemas={type.schemas}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
         />
-        <Query
-          name={query.name}
-          queryOptionsName={queryOptions.name}
-          typeSchemas={type.schemas}
-          pathParamsType={options.pathParamsType}
-          operation={operation}
-          dataReturnType={options.client.dataReturnType}
-          queryKeyName={queryKey.name}
-          queryKeyTypeName={queryKey.typeName}
-        />
+        {options.query && (
+          <>
+            <File.Import name={['createQuery']} path={importPath} />
+            <File.Import name={['QueryKey', 'CreateBaseQueryOptions', 'CreateQueryResult']} path={importPath} isTypeOnly />
+            <Query
+              name={query.name}
+              queryOptionsName={queryOptions.name}
+              typeSchemas={type.schemas}
+              pathParamsType={options.pathParamsType}
+              operation={operation}
+              paramsType={options.paramsType}
+              dataReturnType={options.client.dataReturnType}
+              queryKeyName={queryKey.name}
+              queryKeyTypeName={queryKey.typeName}
+            />
+          </>
+        )}
       </File>
     )
   },

package/src/plugin.ts

@@ -2,7 +2,6 @@ import path from 'node:path'
 
 import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
-import { renderTemplate } from '@kubb/core/utils'
 import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
 
 import { pluginTsName } from '@kubb/plugin-ts'
@@ -10,6 +9,7 @@ import { pluginZodName } from '@kubb/plugin-zod'
 
 import type { Plugin } from '@kubb/core'
 import type { PluginOas } from '@kubb/plugin-oas'
+import { MutationKey, QueryKey } from './components'
 import { mutationGenerator, queryGenerator } from './generators'
 import type { PluginSvelteQuery } from './types.ts'
 
@@ -24,9 +24,12 @@ export const pluginSvelteQuery = createPlugin<PluginSvelteQuery>((options) => {
     override = [],
     parser = 'client',
     transformers = {},
+    paramsType = 'inline',
     pathParamsType = 'inline',
     mutation = {},
     query = {},
+    mutationKey = MutationKey.getTransformer,
+    queryKey = QueryKey.getTransformer,
     generators = [queryGenerator, mutationGenerator].filter(Boolean),
   } = options
 
@@ -34,26 +37,26 @@ export const pluginSvelteQuery = createPlugin<PluginSvelteQuery>((options) => {
     name: pluginSvelteQueryName,
     options: {
       output,
-      baseURL: undefined,
       client: {
         importPath: '@kubb/plugin-client/client',
         dataReturnType: 'data',
         pathParamsType: 'inline',
         ...options.client,
       },
+      queryKey,
       query: {
-        key: (key: unknown[]) => key,
         methods: ['get'],
         importPath: '@tanstack/svelte-query',
         ...query,
       },
+      mutationKey,
       mutation: {
-        key: (key: unknown[]) => key,
         methods: ['post', 'put', 'patch', 'delete'],
         importPath: '@tanstack/svelte-query',
         ...mutation,
       },
-      pathParamsType,
+      paramsType,
+      pathParamsType: paramsType === 'object' ? 'object' : pathParamsType,
       parser,
     },
     pre: [pluginOasName, pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
@@ -103,22 +106,20 @@ export const pluginSvelteQuery = createPlugin<PluginSvelteQuery>((options) => {
       const mode = FileManager.getMode(path.resolve(root, output.path))
       const baseURL = await swaggerPlugin.context.getBaseURL()
 
-      const operationGenerator = new OperationGenerator(
-        {
-          ...this.plugin.options,
-          baseURL,
-        },
-        {
-          oas,
-          pluginManager: this.pluginManager,
-          plugin: this.plugin,
-          contentType: swaggerPlugin.context.contentType,
-          exclude,
-          include,
-          override,
-          mode,
-        },
-      )
+      if (baseURL) {
+        this.plugin.options.client.baseURL = baseURL
+      }
+
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.context.contentType,
+        exclude,
+        include,
+        override,
+        mode,
+      })
 
       const files = await operationGenerator.build(...generators)
       await this.addFile(...files)

package/src/types.ts

@@ -1,14 +1,28 @@
 import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 
-import type { HttpMethod } from '@kubb/oas'
+import type { HttpMethod, Operation } from '@kubb/oas'
 import type { PluginClient } from '@kubb/plugin-client'
-import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+import type { Exclude, Generator, Include, OperationSchemas, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+import type { PluginReactQuery } from '@kubb/plugin-react-query'
+
+type TransformerProps = {
+  operation: Operation
+  schemas: OperationSchemas
+}
+
+export type Transformer = (props: TransformerProps) => unknown[]
+
+/**
+ * Customize the queryKey
+ */
+type QueryKey = Transformer
+
+/**
+ * Customize the mutationKey
+ */
+type MutationKey = Transformer
 
 type Query = {
-  /**
-   * Customize the queryKey, here you can specify a suffix.
-   */
-  key: (key: unknown[]) => unknown[]
   /**
    * Define which HttpMethods can be used for queries
    * @default ['get']
@@ -25,10 +39,6 @@ type Query = {
 }
 
 type Mutation = {
-  /**
-   * Customize the queryKey, here you can specify a suffix.
-   */
-  key: (key: unknown[]) => unknown[]
   /**
    * Define which HttpMethods can be used for mutations
    * @default ['post', 'put', 'delete']
@@ -55,7 +65,7 @@ export type Options = {
    */
   group?: Group
 
-  client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath'>
+  client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath' | 'baseURL'>
 
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
@@ -69,6 +79,13 @@ export type Options = {
    * Array containing override parameters to override `options` based on tags/operations/methods/paths.
    */
   override?: Array<Override<ResolvedOptions>>
+  /**
+   * How to pass your params
+   * - 'object' will return the params and pathParams as an object.
+   * - 'inline' will return the params as comma separated params.
+   * @default 'inline'
+   */
+  paramsType?: 'object' | 'inline'
   /**
    * How to pass your pathParams.
    * - 'object' will return the pathParams as an object.
@@ -76,16 +93,18 @@ export type Options = {
    * @default 'inline'
    */
   pathParamsType?: PluginClient['options']['pathParamsType']
+  queryKey?: QueryKey
   /**
    * Override some useQuery behaviours.
    */
   query?: Partial<Query> | false
+  mutationKey?: MutationKey
   /**
    * Override some useMutation behaviours.
    */
   mutation?: Mutation | false
   /**
-   * Which parser can be used before returning the data to `@tanstack/query`.
+   * Which parser should be used before returning the data to `@tanstack/query`.
    * `'zod'` will use `@kubb/plugin-zod` to parse the data.
    */
   parser?: PluginClient['options']['parser']
@@ -103,11 +122,13 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
-  baseURL: string | undefined
-  client: Required<NonNullable<PluginSvelteQuery['options']['client']>>
+  client: Required<Omit<NonNullable<PluginReactQuery['options']['client']>, 'baseURL'>> & { baseURL?: string }
   parser: Required<NonNullable<Options['parser']>>
+  paramsType: NonNullable<Options['paramsType']>
   pathParamsType: NonNullable<Options['pathParamsType']>
+  queryKey: QueryKey | undefined
   query: NonNullable<Required<Query>> | false
+  mutationKey: MutationKey | undefined
   mutation: NonNullable<Required<Mutation>> | false
 }