@kubb/plugin-svelte-query 3.0.0-alpha.31 → 3.0.0-beta.10

package/dist/types-Cg7Z4H-7.d.ts

@@ -0,0 +1,200 @@
+import { PluginFactoryOptions, Output, Group, ResolveNameParams } from '@kubb/core';
+import { HttpMethod } from '@kubb/oas';
+import { ResolvePathOptions, Exclude, Include, Override, Generator } from '@kubb/plugin-oas';
+
+type Options$1 = {
+    /**
+     * Specify the export location for the files and define the behavior of the output
+     * @default { path: 'clients', barrelType: 'named' }
+     */
+    output?: Output;
+    /**
+     * Group the clients based on the provided name.
+     */
+    group?: Group;
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+     */
+    override?: Array<Override<ResolvedOptions$1>>;
+    /**
+     * Create `operations.ts` file with all operations grouped by methods.
+     * @default false
+     */
+    operations?: boolean;
+    /**
+     * Path to the client import path that will be used to do the API calls.
+     * It will be used as `import client from '${client.importPath}'`.
+     * It allows both relative and absolute path but be aware that we will not change the path.
+     * @default '@kubb/plugin-client/client'
+     */
+    importPath?: string;
+    /**
+     * ReturnType that will be used when calling the client.
+     * - 'data' will return ResponseConfig[data].
+     * - 'full' will return ResponseConfig.
+     * @default 'data'
+     */
+    dataReturnType?: 'data' | 'full';
+    /**
+     * 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.
+     * - 'inline' will return the pathParams as comma separated params.
+     * @default 'inline'
+     */
+    pathParamsType?: 'object' | 'inline';
+    /**
+     * Which parser can be used before returning the data
+     * - 'zod'  will use `@kubb/plugin-zod` to parse the data.
+     * @default 'client'
+     */
+    parser?: 'client' | 'zod';
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+    /**
+     * Define some generators next to the client generators
+     */
+    generators?: Array<Generator<PluginClient>>;
+};
+type ResolvedOptions$1 = {
+    output: Output;
+    group?: Options$1['group'];
+    baseURL: string | undefined;
+    parser: NonNullable<Options$1['parser']>;
+    importPath: NonNullable<Options$1['importPath']>;
+    dataReturnType: NonNullable<Options$1['dataReturnType']>;
+    pathParamsType: NonNullable<Options$1['pathParamsType']>;
+    paramsType: NonNullable<Options$1['paramsType']>;
+};
+type PluginClient = PluginFactoryOptions<'plugin-client', Options$1, ResolvedOptions$1, never, ResolvePathOptions>;
+
+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']
+     */
+    methods: Array<HttpMethod>;
+    /**
+     * Path to the useQuery that will be used to do the useQuery functionality.
+     * It will be used as `import { useQuery } from '${importPath}'`.
+     * It allows both relative and absolute path.
+     * the path will be applied as is, so relative path should be based on the file being generated.
+     * @default '@tanstack/svelte-query'
+     */
+    importPath?: string;
+};
+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']
+     */
+    methods: Array<HttpMethod>;
+    /**
+     * Path to the useQuery that will be used to do the useQuery functionality.
+     * It will be used as `import { useQuery } from '${importPath}'`.
+     * It allows both relative and absolute path.
+     * the path will be applied as is, so relative path should be based on the file being generated.
+     * @default '@tanstack/svelte-query'
+     */
+    importPath?: string;
+};
+type Options = {
+    /**
+     * Specify the export location for the files and define the behavior of the output
+     * @default { path: 'hooks', barrelType: 'named' }
+     */
+    output?: Output;
+    /**
+     * Group the @tanstack/query hooks based on the provided name.
+     */
+    group?: Group;
+    client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath'>;
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * 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.
+     * - 'inline' will return the pathParams as comma separated params.
+     * @default 'inline'
+     */
+    pathParamsType?: PluginClient['options']['pathParamsType'];
+    /**
+     * Override some useQuery behaviours.
+     */
+    query?: Partial<Query> | false;
+    /**
+     * Override some useMutation behaviours.
+     */
+    mutation?: Mutation | false;
+    /**
+     * 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'];
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+    /**
+     * Define some generators next to the svelte-query generators
+     */
+    generators?: Array<Generator<PluginSvelteQuery>>;
+};
+type ResolvedOptions = {
+    output: Output;
+    baseURL: string | undefined;
+    client: Required<NonNullable<PluginSvelteQuery['options']['client']>>;
+    parser: Required<NonNullable<Options['parser']>>;
+    paramsType: NonNullable<Options['paramsType']>;
+    pathParamsType: NonNullable<Options['pathParamsType']>;
+    query: NonNullable<Required<Query>> | false;
+    mutation: NonNullable<Required<Mutation>> | false;
+};
+type PluginSvelteQuery = PluginFactoryOptions<'plugin-svelte-query', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginSvelteQuery as P };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-svelte-query",
-  "version": "3.0.0-alpha.31",
+  "version": "3.0.0-beta.10",
   "description": "Generator svelte-query hooks",
   "keywords": [
     "faker",
@@ -62,24 +62,24 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/core": "3.0.0-alpha.31",
-    "@kubb/fs": "3.0.0-alpha.31",
-    "@kubb/oas": "3.0.0-alpha.31",
-    "@kubb/plugin-oas": "3.0.0-alpha.31",
-    "@kubb/plugin-ts": "3.0.0-alpha.31",
-    "@kubb/plugin-zod": "3.0.0-alpha.31",
-    "@kubb/react": "3.0.0-alpha.31"
+    "@kubb/core": "3.0.0-beta.10",
+    "@kubb/fs": "3.0.0-beta.10",
+    "@kubb/oas": "3.0.0-beta.10",
+    "@kubb/plugin-oas": "3.0.0-beta.10",
+    "@kubb/plugin-ts": "3.0.0-beta.10",
+    "@kubb/plugin-zod": "3.0.0-beta.10",
+    "@kubb/react": "3.0.0-beta.10"
   },
   "devDependencies": {
-    "@types/react": "^18.3.10",
+    "@types/react": "^18.3.12",
     "react": "^18.3.1",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.2",
-    "@kubb/config-ts": "3.0.0-alpha.31",
-    "@kubb/config-tsup": "3.0.0-alpha.31"
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "@kubb/config-ts": "3.0.0-beta.10",
+    "@kubb/config-tsup": "3.0.0-beta.10"
   },
   "peerDependencies": {
-    "@kubb/react": "3.0.0-alpha.31"
+    "@kubb/react": "3.0.0-beta.10"
   },
   "engines": {
     "node": ">=20"

package/src/components/Mutation.tsx

@@ -19,6 +19,7 @@ type Props = {
   mutationKeyName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsType: PluginSvelteQuery['resolvedOptions']['paramsType']
   dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
   pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
 }
@@ -58,7 +59,7 @@ function getParams({ dataReturnType, typeSchemas }: GetParamsProps) {
     options: {
       type: `
 {
-  mutation?: CreateMutationOptions<${[TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error', `{${TRequest}}`].join(', ')}>,
+  mutation?: CreateMutationOptions<${[TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error', TRequest ? `{${TRequest}}` : undefined].filter(Boolean).join(', ')}>,
   client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>'},
 }
 `,
@@ -67,7 +68,7 @@ function getParams({ dataReturnType, typeSchemas }: GetParamsProps) {
   })
 }
 
-export function Mutation({ name, clientName, pathParamsType, dataReturnType, typeSchemas, operation, mutationKeyName }: Props): ReactNode {
+export function Mutation({ name, clientName, paramsType, pathParamsType, dataReturnType, typeSchemas, operation, mutationKeyName }: Props): ReactNode {
   const mutationKeyParams = MutationKey.getParams({
     pathParamsType,
     typeSchemas,
@@ -80,6 +81,7 @@ export function Mutation({ name, clientName, pathParamsType, dataReturnType, typ
   })
 
   const clientParams = Client.getParams({
+    paramsType,
     typeSchemas,
     pathParamsType,
   })
@@ -124,7 +126,9 @@ export function Mutation({ name, clientName, pathParamsType, dataReturnType, typ
 
   const TRequest = mutationParams.toConstructor({ valueAsType: true })
   const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const generics = [TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error', `{${TRequest}}`].join(', ')
+  const generics = [TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error', TRequest ? `{${TRequest}}` : undefined]
+    .filter(Boolean)
+    .join(', ')
 
   return (
     <File.Source name={name} isExportable isIndexable>

package/src/components/Query.tsx

@@ -18,24 +18,68 @@ type Props = {
   queryKeyTypeName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsType: PluginSvelteQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
 }
 
 type GetParamsProps = {
+  paramsType: PluginSvelteQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
   const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
 
+  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,
+        },
+      },
+      options: {
+        type: `
+{
+  query?: Partial<CreateBaseQueryOptions<${[TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error', 'TData', 'TQueryData', 'TQueryKey'].join(', ')}>>,
+  client?: ${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,
@@ -66,7 +110,17 @@ function getParams({ pathParamsType, dataReturnType, typeSchemas }: GetParamsPro
   })
 }
 
-export function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, pathParamsType, dataReturnType, typeSchemas, operation }: Props): ReactNode {
+export function Query({
+  name,
+  queryKeyTypeName,
+  queryOptionsName,
+  queryKeyName,
+  paramsType,
+  pathParamsType,
+  dataReturnType,
+  typeSchemas,
+  operation,
+}: Props): ReactNode {
   const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
   const returnType = `CreateQueryResult<${['TData', typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'].join(', ')}> & { queryKey: TQueryKey }`
   const generics = [`TData = ${TData}`, `TQueryData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`]
@@ -76,10 +130,12 @@ export function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
     typeSchemas,
   })
   const queryOptionsParams = QueryOptions.getParams({
+    paramsType,
     pathParamsType,
     typeSchemas,
   })
   const params = getParams({
+    paramsType,
     pathParamsType,
     dataReturnType,
     typeSchemas,

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__/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 { createQuery, queryOptions } 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__/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'
@@ -89,6 +88,7 @@ export const mutationGenerator = createReactGenerator<PluginSvelteQuery>({
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
@@ -99,6 +99,7 @@ export const mutationGenerator = createReactGenerator<PluginSvelteQuery>({
           typeSchemas={type.schemas}
           operation={operation}
           dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           mutationKeyName={mutationKey.name}
         />

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'
@@ -95,6 +94,7 @@ export const queryGenerator = createReactGenerator<PluginSvelteQuery>({
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
@@ -103,6 +103,7 @@ export const queryGenerator = createReactGenerator<PluginSvelteQuery>({
           clientName={client.name}
           queryKeyName={queryKey.name}
           typeSchemas={type.schemas}
+          paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
         />
         <Query
@@ -111,6 +112,7 @@ export const queryGenerator = createReactGenerator<PluginSvelteQuery>({
           typeSchemas={type.schemas}
           pathParamsType={options.pathParamsType}
           operation={operation}
+          paramsType={options.paramsType}
           dataReturnType={options.client.dataReturnType}
           queryKeyName={queryKey.name}
           queryKeyTypeName={queryKey.typeName}

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'
@@ -24,6 +23,7 @@ export const pluginSvelteQuery = createPlugin<PluginSvelteQuery>((options) => {
     override = [],
     parser = 'client',
     transformers = {},
+    paramsType = 'inline',
     pathParamsType = 'inline',
     mutation = {},
     query = {},
@@ -53,7 +53,8 @@ export const pluginSvelteQuery = createPlugin<PluginSvelteQuery>((options) => {
         importPath: '@tanstack/svelte-query',
         ...mutation,
       },
-      pathParamsType,
+      paramsType,
+      pathParamsType: paramsType === 'object' ? 'object' : pathParamsType,
       parser,
     },
     pre: [pluginOasName, pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),