diff --git a/.changeset/modern-colts-hang.md b/.changeset/modern-colts-hang.md
new file mode 100644
index 000000000..1c17966fe
--- /dev/null
+++ b/.changeset/modern-colts-hang.md
@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+feat(plugin): add `@pinia/colada` plugin
diff --git a/.changeset/olive-pots-rest.md b/.changeset/olive-pots-rest.md
new file mode 100644
index 000000000..75fc6ff34
--- /dev/null
+++ b/.changeset/olive-pots-rest.md
@@ -0,0 +1,23 @@
+---
+'@hey-api/openapi-ts': minor
+---
+
+feat(parser): add Hooks API
+
+### Added Hooks API
+
+This release adds the [Hooks API](https://heyapi.dev/openapi-ts/configuration/parser#hooks), giving you granular control over which operations generate queries and mutations. As a result, we tightened the previous behavior and POST operations no longer generate queries by default. To preserve the old behavior, add a custom matcher.
+
+```js
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  parser: {
+    hooks: {
+      operations: {
+        isQuery: (op) => (op.method === 'post' ? true : undefined),
+      },
+    },
+  },
+};
+```
diff --git a/docs/.vitepress/config/en.ts b/docs/.vitepress/config/en.ts
index 53b22921f..d9e5b4c4b 100644
--- a/docs/.vitepress/config/en.ts
+++ b/docs/.vitepress/config/en.ts
@@ -173,12 +173,12 @@ export default defineConfig({
             collapsed: true,
             items: [
               {
-                link: '/openapi-ts/plugins/tanstack-query',
-                text: 'TanStack Query',
+                link: '/openapi-ts/plugins/pinia-colada',
+                text: 'Pinia Colada',
               },
               {
-                link: '/openapi-ts/plugins/pinia-colada',
-                text: 'Pinia Colada <span data-soon>soon</span>',
+                link: '/openapi-ts/plugins/tanstack-query',
+                text: 'TanStack Query',
               },
               {
                 link: '/openapi-ts/plugins/swr',
diff --git a/docs/data/people.ts b/docs/data/people.ts
index 215f7f86d..662cb18a7 100644
--- a/docs/data/people.ts
+++ b/docs/data/people.ts
@@ -8,7 +8,17 @@ export const jacobCohen: Person = {
   name: 'Jacob Cohen',
 };
 
+export const joshHemphill: Person = {
+  github: 'https://github.com/josh-hemphill',
+  name: 'Josh Hemphill',
+};
+
 export const maxScopp: Person = {
   github: 'https://github.com/max-scopp',
   name: 'Max Scopp',
 };
+
+export const sebastiaanWouters: Person = {
+  github: 'https://github.com/SebastiaanWouters',
+  name: 'Sebastiaan Wouters',
+};
diff --git a/docs/openapi-ts/configuration/parser.md b/docs/openapi-ts/configuration/parser.md
index 87e99e088..d4cf7f3d4 100644
--- a/docs/openapi-ts/configuration/parser.md
+++ b/docs/openapi-ts/configuration/parser.md
@@ -18,9 +18,9 @@ You can add custom patches with `patch`.
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    patch: { // [!code ++]
-      schemas: { // [!code ++]
+  parser: {
+    patch: {
+      schemas: {
         Foo: (schema) => { // [!code ++]
           // convert date-time format to timestamp // [!code ++]
           delete schema.properties.updatedAt.format; // [!code ++]
@@ -38,9 +38,9 @@ export default {
           // remove property // [!code ++]
           delete schema.properties.internalField; // [!code ++]
         }, // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
 <!-- prettier-ignore-end -->
@@ -55,17 +55,15 @@ If you don't control or trust your input, you might want to validate it. Any det
 
 To validate your input, set `validate_EXPERIMENTAL` to `true`.
 
-<!-- prettier-ignore-start -->
 ```js
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
+  parser: {
     validate_EXPERIMENTAL: true, // [!code ++]
-  }, // [!code ++]
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 ## Filters
 
@@ -77,36 +75,33 @@ Set `include` to match operations to be included or `exclude` to match operation
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [include]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      operations: { // [!code ++]
+  parser: {
+    filters: {
+      operations: {
         include: ['GET /api/v1/foo', '/^[A-Z]+ /api/v1//'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [exclude]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      operations: { // [!code ++]
+  parser: {
+    filters: {
+      operations: {
         exclude: ['GET /api/v1/foo', '/^[A-Z]+ /api/v1//'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -116,36 +111,33 @@ Set `include` to match tags to be included or `exclude` to match tags to be excl
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [include]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      tags: { // [!code ++]
+  parser: {
+    filters: {
+      tags: {
         include: ['v2'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [exclude]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      tags: { // [!code ++]
+  parser: {
+    filters: {
+      tags: {
         exclude: ['v1'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -153,19 +145,17 @@ export default {
 
 You can filter out deprecated resources by setting `deprecated` to `false`.
 
-<!-- prettier-ignore-start -->
 ```js
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
+  parser: {
+    filters: {
       deprecated: false, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 ### Schemas
 
@@ -173,36 +163,33 @@ Set `include` to match schemas to be included or `exclude` to match schemas to b
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [include]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      schemas: { // [!code ++]
+  parser: {
+    filters: {
+      schemas: {
         include: ['Foo', '/^Bar/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [exclude]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      schemas: { // [!code ++]
+  parser: {
+    filters: {
+      schemas: {
         exclude: ['Foo', '/^Bar/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -212,36 +199,33 @@ Set `include` to match parameters to be included or `exclude` to match parameter
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [include]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      parameters: { // [!code ++]
+  parser: {
+    filters: {
+      parameters: {
         include: ['QueryParameter', '/^MyQueryParameter/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [exclude]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      parameters: { // [!code ++]
+  parser: {
+    filters: {
+      parameters: {
         exclude: ['QueryParameter', '/^MyQueryParameter/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -251,36 +235,33 @@ Set `include` to match request bodies to be included or `exclude` to match reque
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [include]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      requestBodies: { // [!code ++]
+  parser: {
+    filters: {
+      requestBodies: {
         include: ['Payload', '/^SpecialPayload/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [exclude]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      requestBodies: { // [!code ++]
+  parser: {
+    filters: {
+      requestBodies: {
         exclude: ['Payload', '/^SpecialPayload/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -290,36 +271,33 @@ Set `include` to match responses to be included or `exclude` to match responses
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [include]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      responses: { // [!code ++]
+  parser: {
+    filters: {
+      responses: {
         include: ['Foo', '/^Bar/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [exclude]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
-      responses: { // [!code ++]
+  parser: {
+    filters: {
+      responses: {
         exclude: ['Foo', '/^Bar/'], // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -327,37 +305,33 @@ export default {
 
 If you only want to exclude orphaned resources, set `orphans` to `false`. This is the default value when combined with any other filters. If this isn't the desired behavior, you may want to set `orphans` to `true` to always preserve unused resources.
 
-<!-- prettier-ignore-start -->
 ```js
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
+  parser: {
+    filters: {
       orphans: false, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 ### Order
 
 For performance reasons, we don't preserve the original order when filtering out resources. If maintaining the original order is important to you, set `preserveOrder` to `true`.
 
-<!-- prettier-ignore-start -->
 ```js
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    filters: { // [!code ++]
+  parser: {
+    filters: {
       preserveOrder: true, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 ## Transforms
 
@@ -374,32 +348,29 @@ You may want all enums to be reusable. This is because only root enums are typic
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [root]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    transforms: { // [!code ++]
+  parser: {
+    transforms: {
       enums: 'root', // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [inline]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    transforms: { // [!code ++]
+  parser: {
+    transforms: {
       enums: 'inline', // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -411,35 +382,32 @@ Your schemas might contain read-only or write-only fields. Using such schemas di
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [default]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    transforms: { // [!code ++]
-      readWrite: { // [!code ++]
+  parser: {
+    transforms: {
+      readWrite: {
         requests: '{{name}}Writable', // [!code ++]
         responses: '{{name}}', // [!code ++]
-      }, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+      },
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
-<!-- prettier-ignore-start -->
+
 ```js [disabled]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    transforms: { // [!code ++]
+  parser: {
+    transforms: {
       readWrite: false, // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+    },
+  },
 };
 ```
-<!-- prettier-ignore-end -->
 
 :::
 
@@ -453,31 +421,105 @@ You can provide custom pagination keywords using `pagination.keywords`.
 
 ::: code-group
 
-<!-- prettier-ignore-start -->
 ```js [extend]
 import { defaultPaginationKeywords } from '@hey-api/openapi-ts';
 
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    pagination: { // [!code ++]
-      keywords: [...defaultPaginationKeywords, 'extra', 'pagination', 'keywords'], // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+  parser: {
+    pagination: {
+      keywords: [
+        ...defaultPaginationKeywords, // [!code ++]
+        'extra', // [!code ++]
+        'pagination', // [!code ++]
+        'keywords', // [!code ++]
+      ],
+    },
+  },
+};
+```
+
+```js [override]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  parser: {
+    pagination: {
+      keywords: [
+        'custom', // [!code ++]
+        'pagination', // [!code ++]
+        'keywords', // [!code ++]
+      ],
+    },
+  },
+};
+```
+
+:::
+
+## Hooks
+
+Hooks affect runtime behavior but aren’t tied to any single plugin. They can be configured globally via `parser.hooks` or per plugin through the `~hooks` property.
+
+### Operations {#hooks-operations}
+
+Each operation has a list of classifiers that can include `query`, `mutation`, both, or none. Plugins may use these values to decide whether to generate specific output. For example, you usually don’t want to generate [TanStack Query options](/openapi-ts/plugins/tanstack-query#queries) for PATCH operations.
+
+#### Query operations {#hooks-query-operations}
+
+By default, GET operations are classified as `query` operations.
+
+#### Mutation operations {#hooks-mutation-operations}
+
+By default, DELETE, PATCH, POST, and PUT operations are classified as `mutation` operations.
+
+#### Example: POST search query
+
+Imagine your API has a POST `/search` endpoint that accepts a large payload. By default, it's classified as a `mutation`, but in practice it behaves like a `query`, and your [state management](/openapi-ts/state-management) plugin should generate query hooks.
+
+You can fix this by classifying the operation as `query` in a matcher. If a matcher returns no value, we fall back to less specific matchers until one does.
+
+::: code-group
+
+<!-- prettier-ignore-start -->
+```js [parser]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  parser: {
+    hooks: {
+      operations: {
+        isQuery: (op) => {
+          if (op.method === 'post' && op.path === '/search') { // [!code ++]
+            return true; // [!code ++]
+          } // [!code ++]
+        },
+      },
+    },
+  },
 };
 ```
 <!-- prettier-ignore-end -->
 <!-- prettier-ignore-start -->
-```js [override]
+```js [plugin]
 export default {
   input: 'hey-api/backend', // sign up at app.heyapi.dev
   output: 'src/client',
-  parser: { // [!code ++]
-    pagination: { // [!code ++]
-      keywords: ['custom', 'pagination', 'keywords'], // [!code ++]
-    }, // [!code ++]
-  }, // [!code ++]
+  plugins: [
+    {
+      name: '@tanstack/react-query',
+      '~hooks': {
+        operations: {
+          getKind: (op) => {
+            if (op.method === 'post' && op.path === '/search') { // [!code ++]
+              return ['query']; // [!code ++]
+            } // [!code ++]
+          },
+        },
+      },
+    },
+  ],
 };
 ```
 <!-- prettier-ignore-end -->
diff --git a/docs/openapi-ts/migrating.md b/docs/openapi-ts/migrating.md
index 0df7073de..986cd23f3 100644
--- a/docs/openapi-ts/migrating.md
+++ b/docs/openapi-ts/migrating.md
@@ -7,6 +7,26 @@ description: Migrating to @hey-api/openapi-ts.
 
 While we try to avoid breaking changes, sometimes it's unavoidable in order to offer you the latest features. This page lists changes that require updates to your code. If you run into a problem with migration, please [open an issue](https://github.com/hey-api/openapi-ts/issues).
 
+## v0.82.0
+
+### Added Hooks API
+
+This release adds the [Hooks API](/openapi-ts/configuration/parser#hooks), giving you granular control over which operations generate queries and mutations. As a result, we tightened the previous behavior and POST operations no longer generate queries by default. To preserve the old behavior, add a custom matcher.
+
+```js
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  parser: {
+    hooks: {
+      operations: {
+        isQuery: (op) => (op.method === 'post' ? true : undefined), // [!code ++]
+      },
+    },
+  },
+};
+```
+
 ## v0.81.0
 
 ### Server-Sent Events (SSE)
diff --git a/docs/openapi-ts/plugins.md b/docs/openapi-ts/plugins.md
index 09bad4ed6..321b66c47 100644
--- a/docs/openapi-ts/plugins.md
+++ b/docs/openapi-ts/plugins.md
@@ -20,12 +20,13 @@ Apart from being responsible for the default output, core plugins are the founda
 
 These plugins help reduce boilerplate associated with third-party dependencies. Hey API natively supports the most popular packages. Please open an issue on [GitHub](https://github.com/hey-api/openapi-ts/issues) if you'd like us to support your favorite package.
 
+- [`@angular/common`](/openapi-ts/plugins/angular)
+- [`@pinia/colada`](/openapi-ts/plugins/pinia-colada)
 - [`@tanstack/angular-query-experimental`](/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/react-query`](/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/solid-query`](/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/svelte-query`](/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/vue-query`](/openapi-ts/plugins/tanstack-query)
-- [`@angular/common`](/openapi-ts/plugins/angular)
 - [`fastify`](/openapi-ts/plugins/fastify)
 - [`valibot`](/openapi-ts/plugins/valibot)
 - [`zod`](/openapi-ts/plugins/zod)
@@ -47,7 +48,6 @@ The following plugins are planned but not in development yet. You can help us pr
 - [MSW](/openapi-ts/plugins/msw) <span data-soon>Soon</span>
 - [Nest](/openapi-ts/plugins/nest) <span data-soon>Soon</span>
 - [Nock](/openapi-ts/plugins/nock) <span data-soon>Soon</span>
-- [Pinia Colada](/openapi-ts/plugins/pinia-colada) <span data-soon>Soon</span>
 - [Superstruct](/openapi-ts/plugins/superstruct) <span data-soon>Soon</span>
 - [Supertest](/openapi-ts/plugins/supertest) <span data-soon>Soon</span>
 - [SWR](/openapi-ts/plugins/swr) <span data-soon>Soon</span>
diff --git a/docs/openapi-ts/plugins/pinia-colada.md b/docs/openapi-ts/plugins/pinia-colada.md
index 1b44cf72c..d6aa4b15c 100644
--- a/docs/openapi-ts/plugins/pinia-colada.md
+++ b/docs/openapi-ts/plugins/pinia-colada.md
@@ -1,18 +1,221 @@
 ---
-title: Pinia Colada
-description: Pinia Colada plugin for Hey API. Compatible with all our features.
+title: Pinia Colada v0 Plugin
+description: Generate Pinia Colada v0 functions and query keys from OpenAPI with the Pinia Colada plugin for openapi-ts. Fully compatible with validators, transformers, and all core features.
 ---
 
 <script setup lang="ts">
-import FeatureStatus from '@components/FeatureStatus.vue';
+import AuthorsList from '@components/AuthorsList.vue';
+import Heading from '@components/Heading.vue';
+import VersionLabel from '@components/VersionLabel.vue';
+import { joshHemphill, sebastiaanWouters } from '@data/people.js';
 </script>
 
-# Pinia Colada <span data-soon>soon</span>
-
-<FeatureStatus issueNumber=1242 name="Pinia Colada" />
+<Heading>
+  <h1>Pinia Colada<span class="sr-only"> v0</span></h1>
+  <VersionLabel value="v0" />
+</Heading>
 
 ### About
 
-[Pinia Colada](https://pinia-colada.esm.dev) is the data fetching layer for Pinia.
+[Pinia Colada](https://pinia-colada.esm.dev) is the perfect companion to Pinia to handle async state management in your Vue applications.
+
+The Pinia Colada plugin for Hey API generates functions and query keys from your OpenAPI spec, fully compatible with SDKs, transformers, and all core features.
+
+### Collaborators
+
+<AuthorsList :people="[joshHemphill, sebastiaanWouters]" />
+
+## Features
+
+- Pinia Colada v0 support
+- seamless integration with `@hey-api/openapi-ts` ecosystem
+- create query keys following the best practices
+- type-safe query options and mutation options
+- minimal learning curve thanks to extending the underlying technology
+
+## Installation
+
+In your [configuration](/openapi-ts/get-started), add `@pinia/colada` to your plugins and you'll be ready to generate Pinia Colada artifacts. :tada:
+
+```js
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  plugins: [
+    // ...other plugins
+    '@pinia/colada', // [!code ++]
+  ],
+};
+```
+
+## Output
+
+The Pinia Colada plugin will generate the following artifacts, depending on the input specification.
+
+## Queries
+
+Queries are generated from [query operations](/openapi-ts/configuration/parser#hooks-query-operations). The generated query functions follow the naming convention of SDK functions and by default append `Query`, e.g. `getPetByIdQuery()`.
+
+::: code-group
+
+```ts [example]
+const { data, error } = useQuery({
+  ...getPetByIdQuery({
+    path: {
+      petId: 1,
+    },
+  }),
+});
+```
+
+```js [config]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  plugins: [
+    // ...other plugins
+    {
+      name: '@pinia/colada',
+      queryOptions: true, // [!code ++]
+    },
+  ],
+};
+```
+
+:::
+
+You can customize the naming and casing pattern for `queryOptions` functions using the `.name` and `.case` options.
+
+### Meta
+
+You can use the `meta` field to attach arbitrary information to a query. To generate metadata for `queryOptions`, provide a function to the `.meta` option.
+
+::: code-group
+
+```ts [example]
+queryOptions({
+  // ...other fields
+  meta: {
+    id: 'getPetById',
+  },
+});
+```
+
+```js [config]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  plugins: [
+    // ...other plugins
+    {
+      name: '@pinia/colada',
+      queryOptions: {
+        meta: (operation) => ({ id: operation.id }), // [!code ++]
+      },
+    },
+  ],
+};
+```
+
+:::
+
+## Query Keys
+
+Query keys contain normalized SDK function parameters and additional metadata.
+
+::: code-group
+
+```ts [example]
+const queryKey = [
+  {
+    _id: 'getPetById',
+    baseUrl: 'https://app.heyapi.dev',
+    path: {
+      petId: 1,
+    },
+  },
+];
+```
+
+```js [config]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  plugins: [
+    // ...other plugins
+    {
+      name: '@pinia/colada',
+      queryKeys: true, // [!code ++]
+    },
+  ],
+};
+```
+
+:::
+
+### Accessing Query Keys
+
+If you have access to the result of query options function, you can get the query key from the `queryKey` field.
+
+::: code-group
+
+```ts [example]
+const { queryKey } = getPetByIdOptions({
+  path: {
+    petId: 1,
+  },
+});
+```
+
+```js [config]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  plugins: [
+    // ...other plugins
+    {
+      name: '@pinia/colada',
+      queryOptions: true, // [!code ++]
+    },
+  ],
+};
+```
+
+:::
+
+Alternatively, you can access the same query key by calling query key functions. The generated query key functions follow the naming convention of SDK functions and by default append `QueryKey`, e.g. `getPetByIdQueryKey()`.
+
+::: code-group
+
+```ts [example]
+const queryKey = getPetByIdQueryKey({
+  path: {
+    petId: 1,
+  },
+});
+```
+
+```js [config]
+export default {
+  input: 'hey-api/backend', // sign up at app.heyapi.dev
+  output: 'src/client',
+  plugins: [
+    // ...other plugins
+    {
+      name: '@pinia/colada',
+      queryKeys: true, // [!code ++]
+    },
+  ],
+};
+```
+
+:::
+
+You can customize the naming and casing pattern for `queryKeys` functions using the `.name` and `.case` options.
+
+## API
+
+You can view the complete list of options in the [UserConfig](https://github.com/hey-api/openapi-ts/blob/main/packages/openapi-ts/src/plugins/@pinia/colada/types.d.ts) interface.
 
+<!--@include: ../../partials/examples.md-->
 <!--@include: ../../partials/sponsors.md-->
diff --git a/docs/openapi-ts/plugins/tanstack-query.md b/docs/openapi-ts/plugins/tanstack-query.md
index 3ac4edcb2..13a6f6bc1 100644
--- a/docs/openapi-ts/plugins/tanstack-query.md
+++ b/docs/openapi-ts/plugins/tanstack-query.md
@@ -104,7 +104,7 @@ The TanStack Query plugin will generate the following artifacts, depending on th
 
 ## Queries
 
-Queries are generated from GET and POST endpoints. The generated query functions follow the naming convention of SDK functions and by default append `Options`, e.g. `getPetByIdOptions()`.
+Queries are generated from [query operations](/openapi-ts/configuration/parser#hooks-query-operations). The generated query functions follow the naming convention of SDK functions and by default append `Options`, e.g. `getPetByIdOptions()`.
 
 ::: code-group
 
@@ -302,7 +302,7 @@ You can customize the naming and casing pattern for `queryKeys` functions using
 
 ## Infinite Queries
 
-Infinite queries are generated from GET and POST endpoints if we detect a [pagination](/openapi-ts/configuration/parser#pagination) parameter. The generated infinite query functions follow the naming convention of SDK functions and by default append `InfiniteOptions`, e.g. `getFooInfiniteOptions()`.
+Infinite queries are generated from [query operations](/openapi-ts/configuration/parser#hooks-query-operations) if we detect a [pagination](/openapi-ts/configuration/parser#pagination) parameter. The generated infinite query functions follow the naming convention of SDK functions and by default append `InfiniteOptions`, e.g. `getFooInfiniteOptions()`.
 
 ::: code-group
 
@@ -504,7 +504,7 @@ You can customize the naming and casing pattern for `infiniteQueryKeys` function
 
 ## Mutations
 
-Mutations are generated from DELETE, PATCH, POST, and PUT endpoints. The generated mutation functions follow the naming convention of SDK functions and by default append `Mutation`, e.g. `addPetMutation()`.
+Mutations are generated from [mutation operations](/openapi-ts/configuration/parser#hooks-mutation-operations). The generated mutation functions follow the naming convention of SDK functions and by default append `Mutation`, e.g. `addPetMutation()`.
 
 ::: code-group
 
diff --git a/docs/openapi-ts/state-management.md b/docs/openapi-ts/state-management.md
index 69bad9488..c78f3c668 100644
--- a/docs/openapi-ts/state-management.md
+++ b/docs/openapi-ts/state-management.md
@@ -11,8 +11,8 @@ Any reasonably large application will have to deal with state management at some
 
 Hey API natively supports the following state managers.
 
+- [Pinia Colada](/openapi-ts/plugins/pinia-colada)
 - [TanStack Query](/openapi-ts/plugins/tanstack-query)
-- [Pinia Colada](/openapi-ts/plugins/pinia-colada) <span data-soon>Soon</span>
 - [SWR](/openapi-ts/plugins/swr) <span data-soon>Soon</span>
 - [Zustand](/openapi-ts/plugins/zustand) <span data-soon>Soon</span>
 
diff --git a/examples/openapi-ts-pinia-colada/.eslintrc.cjs b/examples/openapi-ts-pinia-colada/.eslintrc.cjs
new file mode 100644
index 000000000..ff3a044fa
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/.eslintrc.cjs
@@ -0,0 +1,15 @@
+/* eslint-env node */
+require('@rushstack/eslint-patch/modern-module-resolution')
+
+module.exports = {
+  extends: [
+    'plugin:vue/vue3-essential',
+    'eslint:recommended',
+    '@vue/eslint-config-typescript',
+    '@vue/eslint-config-prettier/skip-formatting'
+  ],
+  parserOptions: {
+    ecmaVersion: 'latest'
+  },
+  root: true
+}
diff --git a/examples/openapi-ts-pinia-colada/.gitignore b/examples/openapi-ts-pinia-colada/.gitignore
new file mode 100644
index 000000000..8ee54e8d3
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/.gitignore
@@ -0,0 +1,30 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+.DS_Store
+dist
+dist-ssr
+coverage
+*.local
+
+/cypress/videos/
+/cypress/screenshots/
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+*.tsbuildinfo
diff --git a/examples/openapi-ts-pinia-colada/.prettierrc.json b/examples/openapi-ts-pinia-colada/.prettierrc.json
new file mode 100644
index 000000000..ecdf3e07a
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/.prettierrc.json
@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/prettierrc",
+  "semi": false,
+  "tabWidth": 2,
+  "singleQuote": true,
+  "printWidth": 100,
+  "trailingComma": "none"
+}
diff --git a/examples/openapi-ts-pinia-colada/.vscode/extensions.json b/examples/openapi-ts-pinia-colada/.vscode/extensions.json
new file mode 100644
index 000000000..0449b97dc
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar", "dbaeumer.vscode-eslint", "esbenp.prettier-vscode"]
+}
diff --git a/examples/openapi-ts-pinia-colada/README.md b/examples/openapi-ts-pinia-colada/README.md
new file mode 100644
index 000000000..d75bfa3dc
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/README.md
@@ -0,0 +1,45 @@
+# @hey-api/openapi-ts with Pinia Colada Example
+
+This example demonstrates how to use @hey-api/openapi-ts with Pinia Colada for Vue 3 applications.
+
+## Recommended IDE Setup
+
+[VSCode](https://code.visualstudio.com) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
+
+## Type Support for `.vue` Imports in TS
+
+TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) to make the TypeScript language service aware of `.vue` types.
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vitejs.dev/config).
+
+## Project Setup
+
+```sh
+pnpm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+pnpm dev
+```
+
+### Type-Check, Compile and Minify for Production
+
+```sh
+pnpm build
+```
+
+### Run Unit Tests with [Vitest](https://vitest.dev)
+
+```sh
+pnpm test:unit
+```
+
+### Lint with [ESLint](https://eslint.org)
+
+```sh
+pnpm lint
+```
diff --git a/examples/openapi-ts-pinia-colada/env.d.ts b/examples/openapi-ts-pinia-colada/env.d.ts
new file mode 100644
index 000000000..11f02fe2a
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/examples/openapi-ts-pinia-colada/index.html b/examples/openapi-ts-pinia-colada/index.html
new file mode 100644
index 000000000..768f3f81e
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" href="/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Hey API + Pinia Colada Demo</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/examples/openapi-ts-pinia-colada/openapi-ts.config.ts b/examples/openapi-ts-pinia-colada/openapi-ts.config.ts
new file mode 100644
index 000000000..7a00915a4
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/openapi-ts.config.ts
@@ -0,0 +1,24 @@
+import { defineConfig } from '@hey-api/openapi-ts'
+
+export default defineConfig({
+  input:
+    'https://raw.githubusercontent.com/swagger-api/swagger-petstore/master/src/main/resources/openapi.yaml',
+  output: {
+    format: 'prettier',
+    lint: 'eslint',
+    path: './src/client'
+  },
+  plugins: [
+    '@hey-api/client-fetch',
+    '@hey-api/schemas',
+    '@hey-api/sdk',
+    {
+      enums: 'javascript',
+      name: '@hey-api/typescript'
+    },
+    {
+      exportFromIndex: true,
+      name: '@pinia/colada'
+    }
+  ]
+})
diff --git a/examples/openapi-ts-pinia-colada/package.json b/examples/openapi-ts-pinia-colada/package.json
new file mode 100644
index 000000000..9718ddd69
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/package.json
@@ -0,0 +1,50 @@
+{
+  "name": "@example/openapi-ts-pinia-colada",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "build-only": "vite build",
+    "build": "run-p typecheck \"build-only {@}\" --",
+    "dev": "vite",
+    "format": "prettier --write src/",
+    "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
+    "openapi-ts": "openapi-ts",
+    "preview": "vite preview",
+    "test:unit": "vitest",
+    "typecheck": "vue-tsc --build --force"
+  },
+  "dependencies": {
+    "@pinia/colada": "0.17.2",
+    "pinia": "2.3.0",
+    "vue": "3.5.13",
+    "vue-router": "4.5.0"
+  },
+  "devDependencies": {
+    "@config/vite-base": "workspace:*",
+    "@hey-api/openapi-ts": "workspace:*",
+    "@rushstack/eslint-patch": "1.10.5",
+    "@tsconfig/node20": "20.1.4",
+    "@types/jsdom": "21.1.7",
+    "@types/node": "22.10.5",
+    "@vitejs/plugin-vue": "5.2.1",
+    "@vitejs/plugin-vue-jsx": "4.1.1",
+    "@vue/eslint-config-prettier": "10.1.0",
+    "@vue/eslint-config-typescript": "14.2.0",
+    "@vue/test-utils": "2.4.6",
+    "@vue/tsconfig": "0.7.0",
+    "autoprefixer": "10.4.20",
+    "eslint": "9.17.0",
+    "eslint-plugin-vue": "9.32.0",
+    "jsdom": "23.0.0",
+    "npm-run-all2": "6.2.0",
+    "postcss": "8.4.41",
+    "prettier": "3.4.2",
+    "tailwindcss": "3.4.9",
+    "typescript": "5.8.3",
+    "vite": "7.1.2",
+    "vite-plugin-vue-devtools": "7.7.0",
+    "vitest": "3.1.1",
+    "vue-tsc": "2.2.0"
+  }
+}
diff --git a/examples/openapi-ts-pinia-colada/postcss.config.js b/examples/openapi-ts-pinia-colada/postcss.config.js
new file mode 100644
index 000000000..9ed16a0e8
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/postcss.config.js
@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    autoprefixer: {},
+    tailwindcss: {}
+  }
+}
diff --git a/examples/openapi-ts-pinia-colada/src/App.vue b/examples/openapi-ts-pinia-colada/src/App.vue
new file mode 100644
index 000000000..71749443b
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/App.vue
@@ -0,0 +1,9 @@
+<script setup lang="ts">
+import { RouterView } from 'vue-router'
+</script>
+
+<template>
+  <div>
+    <RouterView />
+  </div>
+</template>
diff --git a/examples/openapi-ts-pinia-colada/src/assets/main.css b/examples/openapi-ts-pinia-colada/src/assets/main.css
new file mode 100644
index 000000000..0a2ac6aac
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/assets/main.css
@@ -0,0 +1,7 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  @apply bg-[#111113];
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/@pinia/colada.gen.ts b/examples/openapi-ts-pinia-colada/src/client/@pinia/colada.gen.ts
new file mode 100644
index 000000000..21f009747
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/@pinia/colada.gen.ts
@@ -0,0 +1,294 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import {
+  addPet,
+  createUser,
+  createUsersWithListInput,
+  deleteOrder,
+  deletePet,
+  deleteUser,
+  findPetsByStatus,
+  findPetsByTags,
+  getInventory,
+  getOrderById,
+  getPetById,
+  getUserByName,
+  loginUser,
+  logoutUser,
+  type Options,
+  placeOrder,
+  updatePet,
+  updatePetWithForm,
+  updateUser,
+  uploadFile
+} from '../sdk.gen'
+import type {
+  AddPetData,
+  CreateUserData,
+  CreateUsersWithListInputData,
+  DeleteOrderData,
+  DeletePetData,
+  DeleteUserData,
+  FindPetsByStatusData,
+  FindPetsByTagsData,
+  GetInventoryData,
+  GetOrderByIdData,
+  GetPetByIdData,
+  GetUserByNameData,
+  LoginUserData,
+  LogoutUserData,
+  PlaceOrderData,
+  UpdatePetData,
+  UpdatePetWithFormData,
+  UpdateUserData,
+  UploadFileData
+} from '../types.gen'
+
+/**
+ * Add a new pet to the store.
+ * Add a new pet to the store.
+ */
+export const addPetMutation = () => ({
+  mutation: async (options: Options<AddPetData>) => {
+    const { data } = await addPet(options)
+    return data
+  }
+})
+
+/**
+ * Update an existing pet.
+ * Update an existing pet by Id.
+ */
+export const updatePetMutation = () => ({
+  mutation: async (options: Options<UpdatePetData>) => {
+    const { data } = await updatePet(options)
+    return data
+  }
+})
+
+/**
+ * Finds Pets by status.
+ * Multiple status values can be provided with comma separated strings.
+ */
+export const findPetsByStatusQuery = (options: Options<FindPetsByStatusData>) => ({
+  key: ['findPetsByStatus', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await findPetsByStatus({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Finds Pets by tags.
+ * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ */
+export const findPetsByTagsQuery = (options: Options<FindPetsByTagsData>) => ({
+  key: ['findPetsByTags', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await findPetsByTags({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Deletes a pet.
+ * Delete a pet.
+ */
+export const deletePetMutation = () => ({
+  mutation: async (options: Options<DeletePetData>) => {
+    const { data } = await deletePet(options)
+    return data
+  }
+})
+
+/**
+ * Find pet by ID.
+ * Returns a single pet.
+ */
+export const getPetByIdQuery = (options: Options<GetPetByIdData>) => ({
+  key: ['getPetById', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await getPetById({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Updates a pet in the store with form data.
+ * Updates a pet resource based on the form data.
+ */
+export const updatePetWithFormMutation = () => ({
+  mutation: async (options: Options<UpdatePetWithFormData>) => {
+    const { data } = await updatePetWithForm(options)
+    return data
+  }
+})
+
+/**
+ * Uploads an image.
+ * Upload image of the pet.
+ */
+export const uploadFileMutation = () => ({
+  mutation: async (options: Options<UploadFileData>) => {
+    const { data } = await uploadFile(options)
+    return data
+  }
+})
+
+/**
+ * Returns pet inventories by status.
+ * Returns a map of status codes to quantities.
+ */
+export const getInventoryQuery = (options?: Options<GetInventoryData>) => ({
+  key: ['getInventory', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await getInventory({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Place an order for a pet.
+ * Place a new order in the store.
+ */
+export const placeOrderMutation = () => ({
+  mutation: async (options: Options<PlaceOrderData>) => {
+    const { data } = await placeOrder(options)
+    return data
+  }
+})
+
+/**
+ * Delete purchase order by identifier.
+ * For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.
+ */
+export const deleteOrderMutation = () => ({
+  mutation: async (options: Options<DeleteOrderData>) => {
+    const { data } = await deleteOrder(options)
+    return data
+  }
+})
+
+/**
+ * Find purchase order by ID.
+ * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.
+ */
+export const getOrderByIdQuery = (options: Options<GetOrderByIdData>) => ({
+  key: ['getOrderById', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await getOrderById({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Create user.
+ * This can only be done by the logged in user.
+ */
+export const createUserMutation = () => ({
+  mutation: async (options: Options<CreateUserData>) => {
+    const { data } = await createUser(options)
+    return data
+  }
+})
+
+/**
+ * Creates list of users with given input array.
+ * Creates list of users with given input array.
+ */
+export const createUsersWithListInputMutation = () => ({
+  mutation: async (options: Options<CreateUsersWithListInputData>) => {
+    const { data } = await createUsersWithListInput(options)
+    return data
+  }
+})
+
+/**
+ * Logs user into the system.
+ * Log into the system.
+ */
+export const loginUserQuery = (options?: Options<LoginUserData>) => ({
+  key: ['loginUser', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await loginUser({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Logs out current logged in user session.
+ * Log user out of the system.
+ */
+export const logoutUserQuery = (options?: Options<LogoutUserData>) => ({
+  key: ['logoutUser', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await logoutUser({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Delete user resource.
+ * This can only be done by the logged in user.
+ */
+export const deleteUserMutation = () => ({
+  mutation: async (options: Options<DeleteUserData>) => {
+    const { data } = await deleteUser(options)
+    return data
+  }
+})
+
+/**
+ * Get user by user name.
+ * Get user detail based on username.
+ */
+export const getUserByNameQuery = (options: Options<GetUserByNameData>) => ({
+  key: ['getUserByName', options?.path],
+  query: async (context: { signal: AbortSignal }) => {
+    const { data } = await getUserByName({
+      ...options,
+      signal: context.signal,
+      throwOnError: true
+    })
+    return data
+  }
+})
+
+/**
+ * Update user resource.
+ * This can only be done by the logged in user.
+ */
+export const updateUserMutation = () => ({
+  mutation: async (options: Options<UpdateUserData>) => {
+    const { data } = await updateUser(options)
+    return data
+  }
+})
diff --git a/examples/openapi-ts-pinia-colada/src/client/client.gen.ts b/examples/openapi-ts-pinia-colada/src/client/client.gen.ts
new file mode 100644
index 000000000..1984dc18c
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/client.gen.ts
@@ -0,0 +1,27 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import {
+  type ClientOptions as DefaultClientOptions,
+  type Config,
+  createClient,
+  createConfig
+} from './client'
+import type { ClientOptions } from './types.gen'
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (
+  override?: Config<DefaultClientOptions & T>
+) => Config<Required<DefaultClientOptions> & T>
+
+export const client = createClient(
+  createConfig<ClientOptions>({
+    baseUrl: 'https://petstore3.swagger.io/api/v3'
+  })
+)
diff --git a/examples/openapi-ts-pinia-colada/src/client/client/client.gen.ts b/examples/openapi-ts-pinia-colada/src/client/client/client.gen.ts
new file mode 100644
index 000000000..65910541f
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/client/client.gen.ts
@@ -0,0 +1,225 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from '../core/serverSentEvents.gen'
+import type { HttpMethod } from '../core/types.gen'
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from './types.gen'
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams
+} from './utils.gen'
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any
+  headers: ReturnType<typeof mergeHeaders>
+}
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config)
+
+  const getConfig = (): Config => ({ ..._config })
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config)
+    return getConfig()
+  }
+
+  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>()
+
+  const beforeRequest = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined
+    }
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      })
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts)
+    }
+
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body)
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.serializedBody === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type')
+    }
+
+    const url = buildUrl(opts)
+
+    return { opts, url }
+  }
+
+  const request: Client['request'] = async (options) => {
+    // @ts-expect-error
+    const { opts, url } = await beforeRequest(options)
+    const requestInit: ReqInit = {
+      redirect: 'follow',
+      ...opts,
+      body: opts.serializedBody
+    }
+
+    let request = new Request(url, requestInit)
+
+    for (const fn of interceptors.request._fns) {
+      if (fn) {
+        request = await fn(request, opts)
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!
+    let response = await _fetch(request)
+
+    for (const fn of interceptors.response._fns) {
+      if (fn) {
+        response = await fn(response, request, opts)
+      }
+    }
+
+    const result = {
+      request,
+      response
+    }
+
+    if (response.ok) {
+      if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+        return opts.responseStyle === 'data'
+          ? {}
+          : {
+              data: {},
+              ...result
+            }
+      }
+
+      const parseAs =
+        (opts.parseAs === 'auto'
+          ? getParseAs(response.headers.get('Content-Type'))
+          : opts.parseAs) ?? 'json'
+
+      let data: any
+      switch (parseAs) {
+        case 'arrayBuffer':
+        case 'blob':
+        case 'formData':
+        case 'json':
+        case 'text':
+          data = await response[parseAs]()
+          break
+        case 'stream':
+          return opts.responseStyle === 'data'
+            ? response.body
+            : {
+                data: response.body,
+                ...result
+              }
+      }
+
+      if (parseAs === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data)
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data)
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? data
+        : {
+            data,
+            ...result
+          }
+    }
+
+    const textError = await response.text()
+    let jsonError: unknown
+
+    try {
+      jsonError = JSON.parse(textError)
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError
+    let finalError = error
+
+    for (const fn of interceptors.error._fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string
+      }
+    }
+
+    finalError = finalError || ({} as string)
+
+    if (opts.throwOnError) {
+      throw finalError
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === 'data'
+      ? undefined
+      : {
+          error: finalError,
+          ...result
+        }
+  }
+
+  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+    request({ ...options, method })
+
+  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+    const { opts, url } = await beforeRequest(options)
+    return createSseClient({
+      ...opts,
+      body: opts.body as BodyInit | null | undefined,
+      headers: opts.headers as unknown as Record<string, string>,
+      method,
+      url
+    })
+  }
+
+  return {
+    buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE')
+    },
+    trace: makeMethodFn('TRACE')
+  } as Client
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/client/index.ts b/examples/openapi-ts-pinia-colada/src/client/client/index.ts
new file mode 100644
index 000000000..1b9721d0a
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/client/index.ts
@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen'
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen'
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer
+} from '../core/bodySerializer.gen'
+export { buildClientParams } from '../core/params.gen'
+export { createClient } from './client.gen'
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  OptionsLegacyParser,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape
+} from './types.gen'
+export { createConfig, mergeHeaders } from './utils.gen'
diff --git a/examples/openapi-ts-pinia-colada/src/client/client/types.gen.ts b/examples/openapi-ts-pinia-colada/src/client/client/types.gen.ts
new file mode 100644
index 000000000..273baf786
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/client/types.gen.ts
@@ -0,0 +1,226 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth } from '../core/auth.gen'
+import type { ServerSentEventsOptions, ServerSentEventsResult } from '../core/serverSentEvents.gen'
+import type { Client as CoreClient, Config as CoreConfig } from '../core/types.gen'
+import type { Middleware } from './utils.gen'
+
+export type ResponseStyle = 'data' | 'fields'
+
+export interface Config<T extends ClientOptions = ClientOptions>
+  extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
+    CoreConfig {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl']
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: (request: Request) => ReturnType<typeof fetch>
+  /**
+   * Please don't use the Fetch client for Next.js applications. The `next`
+   * options won't have any effect.
+   *
+   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+   */
+  next?: never
+  /**
+   * Return the response data parsed in a specified format. By default, `auto`
+   * will infer the appropriate method from the `Content-Type` response header.
+   * You can override this behavior with any of the {@link Body} methods.
+   * Select `stream` if you don't want to parse response data at all.
+   *
+   * @default 'auto'
+   */
+  parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text'
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError']
+}
+
+export interface RequestOptions<
+  TData = unknown,
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string
+> extends Config<{
+      responseStyle: TResponseStyle
+      throwOnError: ThrowOnError
+    }>,
+    Pick<
+      ServerSentEventsOptions<TData>,
+      | 'onSseError'
+      | 'onSseEvent'
+      | 'sseDefaultRetryDelay'
+      | 'sseMaxRetryAttempts'
+      | 'sseMaxRetryDelay'
+    > {
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown
+  path?: Record<string, unknown>
+  query?: Record<string, unknown>
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>
+  url: Url
+}
+
+export interface ResolvedRequestOptions<
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string
+> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+  serializedBody?: string
+}
+
+export type RequestResult<
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields'
+> = ThrowOnError extends true
+  ? Promise<
+      TResponseStyle extends 'data'
+        ? TData extends Record<string, unknown>
+          ? TData[keyof TData]
+          : TData
+        : {
+            data: TData extends Record<string, unknown> ? TData[keyof TData] : TData
+            request: Request
+            response: Response
+          }
+    >
+  : Promise<
+      TResponseStyle extends 'data'
+        ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined
+        : (
+            | {
+                data: TData extends Record<string, unknown> ? TData[keyof TData] : TData
+                error: undefined
+              }
+            | {
+                data: undefined
+                error: TError extends Record<string, unknown> ? TError[keyof TError] : TError
+              }
+          ) & {
+            request: Request
+            response: Response
+          }
+    >
+
+export interface ClientOptions {
+  baseUrl?: string
+  responseStyle?: ResponseStyle
+  throwOnError?: boolean
+}
+
+type MethodFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields'
+>(
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>
+
+type SseFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields'
+>(
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>
+) => Promise<ServerSentEventsResult<TData, TError>>
+
+type RequestFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields'
+>(
+  options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> &
+    Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>
+
+type BuildUrlFn = <
+  TData extends {
+    body?: unknown
+    path?: Record<string, unknown>
+    query?: Record<string, unknown>
+    url: string
+  }
+>(
+  options: Pick<TData, 'url'> & Options<TData>
+) => string
+
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>
+}
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
+  override?: Config<ClientOptions & T>
+) => Config<Required<ClientOptions> & T>
+
+export interface TDataShape {
+  body?: unknown
+  headers?: unknown
+  path?: unknown
+  query?: unknown
+  url: string
+}
+
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>
+
+export type Options<
+  TData extends TDataShape = TDataShape,
+  ThrowOnError extends boolean = boolean,
+  TResponse = unknown,
+  TResponseStyle extends ResponseStyle = 'fields'
+> = OmitKeys<
+  RequestOptions<TResponse, TResponseStyle, ThrowOnError>,
+  'body' | 'path' | 'query' | 'url'
+> &
+  Omit<TData, 'url'>
+
+export type OptionsLegacyParser<
+  TData = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields'
+> = TData extends { body?: any }
+  ? TData extends { headers?: any }
+    ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'body' | 'headers' | 'url'> &
+        TData
+    : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'body' | 'url'> &
+        TData &
+        Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'headers'>
+  : TData extends { headers?: any }
+    ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'headers' | 'url'> &
+        TData &
+        Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'body'>
+    : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, 'url'> & TData
diff --git a/examples/openapi-ts-pinia-colada/src/client/client/utils.gen.ts b/examples/openapi-ts-pinia-colada/src/client/client/utils.gen.ts
new file mode 100644
index 000000000..f701b3d78
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/client/utils.gen.ts
@@ -0,0 +1,310 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { getAuthToken } from '../core/auth.gen'
+import type { QuerySerializerOptions } from '../core/bodySerializer.gen'
+import { jsonBodySerializer } from '../core/bodySerializer.gen'
+import {
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam
+} from '../core/pathSerializer.gen'
+import { getUrl } from '../core/utils.gen'
+import type { Client, ClientOptions, Config, RequestOptions } from './types.gen'
+
+export const createQuerySerializer = <T = unknown>({
+  allowReserved,
+  array,
+  object
+}: QuerySerializerOptions = {}) => {
+  const querySerializer = (queryParams: T) => {
+    const search: string[] = []
+    if (queryParams && typeof queryParams === 'object') {
+      for (const name in queryParams) {
+        const value = queryParams[name]
+
+        if (value === undefined || value === null) {
+          continue
+        }
+
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved,
+            explode: true,
+            name,
+            style: 'form',
+            value,
+            ...array
+          })
+          if (serializedArray) search.push(serializedArray)
+        } else if (typeof value === 'object') {
+          const serializedObject = serializeObjectParam({
+            allowReserved,
+            explode: true,
+            name,
+            style: 'deepObject',
+            value: value as Record<string, unknown>,
+            ...object
+          })
+          if (serializedObject) search.push(serializedObject)
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved,
+            name,
+            value: value as string
+          })
+          if (serializedPrimitive) search.push(serializedPrimitive)
+        }
+      }
+    }
+    return search.join('&')
+  }
+  return querySerializer
+}
+
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export const getParseAs = (contentType: string | null): Exclude<Config['parseAs'], 'auto'> => {
+  if (!contentType) {
+    // If no Content-Type header is provided, the best we can do is return the raw response body,
+    // which is effectively the same as the 'stream' option.
+    return 'stream'
+  }
+
+  const cleanContent = contentType.split(';')[0]?.trim()
+
+  if (!cleanContent) {
+    return
+  }
+
+  if (cleanContent.startsWith('application/json') || cleanContent.endsWith('+json')) {
+    return 'json'
+  }
+
+  if (cleanContent === 'multipart/form-data') {
+    return 'formData'
+  }
+
+  if (
+    ['application/', 'audio/', 'image/', 'video/'].some((type) => cleanContent.startsWith(type))
+  ) {
+    return 'blob'
+  }
+
+  if (cleanContent.startsWith('text/')) {
+    return 'text'
+  }
+
+  return
+}
+
+const checkForExistence = (
+  options: Pick<RequestOptions, 'auth' | 'query'> & {
+    headers: Headers
+  },
+  name?: string
+): boolean => {
+  if (!name) {
+    return false
+  }
+  if (
+    options.headers.has(name) ||
+    options.query?.[name] ||
+    options.headers.get('Cookie')?.includes(`${name}=`)
+  ) {
+    return true
+  }
+  return false
+}
+
+export const setAuthParams = async ({
+  security,
+  ...options
+}: Pick<Required<RequestOptions>, 'security'> &
+  Pick<RequestOptions, 'auth' | 'query'> & {
+    headers: Headers
+  }) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue
+    }
+
+    const token = await getAuthToken(auth, options.auth)
+
+    if (!token) {
+      continue
+    }
+
+    const name = auth.name ?? 'Authorization'
+
+    switch (auth.in) {
+      case 'query':
+        if (!options.query) {
+          options.query = {}
+        }
+        options.query[name] = token
+        break
+      case 'cookie':
+        options.headers.append('Cookie', `${name}=${token}`)
+        break
+      case 'header':
+      default:
+        options.headers.set(name, token)
+        break
+    }
+  }
+}
+
+export const buildUrl: Client['buildUrl'] = (options) =>
+  getUrl({
+    baseUrl: options.baseUrl as string,
+    path: options.path,
+    query: options.query,
+    querySerializer:
+      typeof options.querySerializer === 'function'
+        ? options.querySerializer
+        : createQuerySerializer(options.querySerializer),
+    url: options.url
+  })
+
+export const mergeConfigs = (a: Config, b: Config): Config => {
+  const config = { ...a, ...b }
+  if (config.baseUrl?.endsWith('/')) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1)
+  }
+  config.headers = mergeHeaders(a.headers, b.headers)
+  return config
+}
+
+export const mergeHeaders = (
+  ...headers: Array<Required<Config>['headers'] | undefined>
+): Headers => {
+  const mergedHeaders = new Headers()
+  for (const header of headers) {
+    if (!header || typeof header !== 'object') {
+      continue
+    }
+
+    const iterator = header instanceof Headers ? header.entries() : Object.entries(header)
+
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key)
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v as string)
+        }
+      } else if (value !== undefined) {
+        // assume object headers are meant to be JSON stringified, i.e. their
+        // content value in OpenAPI specification is 'application/json'
+        mergedHeaders.set(
+          key,
+          typeof value === 'object' ? JSON.stringify(value) : (value as string)
+        )
+      }
+    }
+  }
+  return mergedHeaders
+}
+
+type ErrInterceptor<Err, Res, Req, Options> = (
+  error: Err,
+  response: Res,
+  request: Req,
+  options: Options
+) => Err | Promise<Err>
+
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>
+
+type ResInterceptor<Res, Req, Options> = (
+  response: Res,
+  request: Req,
+  options: Options
+) => Res | Promise<Res>
+
+class Interceptors<Interceptor> {
+  _fns: (Interceptor | null)[]
+
+  constructor() {
+    this._fns = []
+  }
+
+  clear() {
+    this._fns = []
+  }
+
+  getInterceptorIndex(id: number | Interceptor): number {
+    if (typeof id === 'number') {
+      return this._fns[id] ? id : -1
+    } else {
+      return this._fns.indexOf(id)
+    }
+  }
+  exists(id: number | Interceptor) {
+    const index = this.getInterceptorIndex(id)
+    return !!this._fns[index]
+  }
+
+  eject(id: number | Interceptor) {
+    const index = this.getInterceptorIndex(id)
+    if (this._fns[index]) {
+      this._fns[index] = null
+    }
+  }
+
+  update(id: number | Interceptor, fn: Interceptor) {
+    const index = this.getInterceptorIndex(id)
+    if (this._fns[index]) {
+      this._fns[index] = fn
+      return id
+    } else {
+      return false
+    }
+  }
+
+  use(fn: Interceptor) {
+    this._fns = [...this._fns, fn]
+    return this._fns.length - 1
+  }
+}
+
+// `createInterceptors()` response, meant for external use as it does not
+// expose internals
+export interface Middleware<Req, Res, Err, Options> {
+  error: Pick<Interceptors<ErrInterceptor<Err, Res, Req, Options>>, 'eject' | 'use'>
+  request: Pick<Interceptors<ReqInterceptor<Req, Options>>, 'eject' | 'use'>
+  response: Pick<Interceptors<ResInterceptor<Res, Req, Options>>, 'eject' | 'use'>
+}
+
+// do not add `Middleware` as return type so we can use _fns internally
+export const createInterceptors = <Req, Res, Err, Options>() => ({
+  error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
+  request: new Interceptors<ReqInterceptor<Req, Options>>(),
+  response: new Interceptors<ResInterceptor<Res, Req, Options>>()
+})
+
+const defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: 'form'
+  },
+  object: {
+    explode: true,
+    style: 'deepObject'
+  }
+})
+
+const defaultHeaders = {
+  'Content-Type': 'application/json'
+}
+
+export const createConfig = <T extends ClientOptions = ClientOptions>(
+  override: Config<Omit<ClientOptions, keyof T> & T> = {}
+): Config<Omit<ClientOptions, keyof T> & T> => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: 'auto',
+  querySerializer: defaultQuerySerializer,
+  ...override
+})
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/auth.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/auth.gen.ts
new file mode 100644
index 000000000..dc8ff6197
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/auth.gen.ts
@@ -0,0 +1,41 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type AuthToken = string | undefined
+
+export interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie'
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string
+  scheme?: 'basic' | 'bearer'
+  type: 'apiKey' | 'http'
+}
+
+export const getAuthToken = async (
+  auth: Auth,
+  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken
+): Promise<string | undefined> => {
+  const token = typeof callback === 'function' ? await callback(auth) : callback
+
+  if (!token) {
+    return
+  }
+
+  if (auth.scheme === 'bearer') {
+    return `Bearer ${token}`
+  }
+
+  if (auth.scheme === 'basic') {
+    return `Basic ${btoa(token)}`
+  }
+
+  return token
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/bodySerializer.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/bodySerializer.gen.ts
new file mode 100644
index 000000000..e39c6a559
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/bodySerializer.gen.ts
@@ -0,0 +1,76 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { ArrayStyle, ObjectStyle, SerializerOptions } from './pathSerializer.gen'
+
+export type QuerySerializer = (query: Record<string, unknown>) => string
+
+export type BodySerializer = (body: any) => any
+
+export interface QuerySerializerOptions {
+  allowReserved?: boolean
+  array?: SerializerOptions<ArrayStyle>
+  object?: SerializerOptions<ObjectStyle>
+}
+
+const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {
+  if (typeof value === 'string' || value instanceof Blob) {
+    data.append(key, value)
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString())
+  } else {
+    data.append(key, JSON.stringify(value))
+  }
+}
+
+const serializeUrlSearchParamsPair = (data: URLSearchParams, key: string, value: unknown): void => {
+  if (typeof value === 'string') {
+    data.append(key, value)
+  } else {
+    data.append(key, JSON.stringify(value))
+  }
+}
+
+export const formDataBodySerializer = {
+  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    body: T
+  ): FormData => {
+    const data = new FormData()
+
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v))
+      } else {
+        serializeFormDataPair(data, key, value)
+      }
+    })
+
+    return data
+  }
+}
+
+export const jsonBodySerializer = {
+  bodySerializer: <T>(body: T): string =>
+    JSON.stringify(body, (_key, value) => (typeof value === 'bigint' ? value.toString() : value))
+}
+
+export const urlSearchParamsBodySerializer = {
+  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): string => {
+    const data = new URLSearchParams()
+
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v))
+      } else {
+        serializeUrlSearchParamsPair(data, key, value)
+      }
+    })
+
+    return data.toString()
+  }
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/params.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/params.gen.ts
new file mode 100644
index 000000000..34dddb5fa
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/params.gen.ts
@@ -0,0 +1,144 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+type Slot = 'body' | 'headers' | 'path' | 'query'
+
+export type Field =
+  | {
+      in: Exclude<Slot, 'body'>
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If omitted, we use the same value as `key`.
+       */
+      map?: string
+    }
+  | {
+      in: Extract<Slot, 'body'>
+      /**
+       * Key isn't required for bodies.
+       */
+      key?: string
+      map?: string
+    }
+
+export interface Fields {
+  allowExtra?: Partial<Record<Slot, boolean>>
+  args?: ReadonlyArray<Field>
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>
+
+const extraPrefixesMap: Record<string, Slot> = {
+  $body_: 'body',
+  $headers_: 'headers',
+  $path_: 'path',
+  $query_: 'query'
+}
+const extraPrefixes = Object.entries(extraPrefixesMap)
+
+type KeyMap = Map<
+  string,
+  {
+    in: Slot
+    map?: string
+  }
+>
+
+const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+  if (!map) {
+    map = new Map()
+  }
+
+  for (const config of fields) {
+    if ('in' in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map
+        })
+      }
+    } else if (config.args) {
+      buildKeyMap(config.args, map)
+    }
+  }
+
+  return map
+}
+
+interface Params {
+  body: unknown
+  headers: Record<string, unknown>
+  path: Record<string, unknown>
+  query: Record<string, unknown>
+}
+
+const stripEmptySlots = (params: Params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === 'object' && !Object.keys(value).length) {
+      delete params[slot as Slot]
+    }
+  }
+}
+
+export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsConfig) => {
+  const params: Params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {}
+  }
+
+  const map = buildKeyMap(fields)
+
+  let config: FieldsConfig[number] | undefined
+
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index]
+    }
+
+    if (!config) {
+      continue
+    }
+
+    if ('in' in config) {
+      if (config.key) {
+        const field = map.get(config.key)!
+        const name = field.map || config.key
+        ;(params[field.in] as Record<string, unknown>)[name] = arg
+      } else {
+        params.body = arg
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key)
+
+        if (field) {
+          const name = field.map || key
+          ;(params[field.in] as Record<string, unknown>)[name] = value
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix))
+
+          if (extra) {
+            const [prefix, slot] = extra
+            ;(params[slot] as Record<string, unknown>)[key.slice(prefix.length)] = value
+          } else {
+            for (const [slot, allowed] of Object.entries(config.allowExtra ?? {})) {
+              if (allowed) {
+                ;(params[slot as Slot] as Record<string, unknown>)[key] = value
+                break
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  stripEmptySlots(params)
+
+  return params
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/pathSerializer.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/pathSerializer.gen.ts
new file mode 100644
index 000000000..acc13672e
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/pathSerializer.gen.ts
@@ -0,0 +1,171 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+interface SerializeOptions<T> extends SerializePrimitiveOptions, SerializerOptions<T> {}
+
+interface SerializePrimitiveOptions {
+  allowReserved?: boolean
+  name: string
+}
+
+export interface SerializerOptions<T> {
+  /**
+   * @default true
+   */
+  explode: boolean
+  style: T
+}
+
+export type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited'
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle
+type MatrixStyle = 'label' | 'matrix' | 'simple'
+export type ObjectStyle = 'form' | 'deepObject'
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle
+
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+  value: string
+}
+
+export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
+  switch (style) {
+    case 'label':
+      return '.'
+    case 'matrix':
+      return ';'
+    case 'simple':
+      return ','
+    default:
+      return '&'
+  }
+}
+
+export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
+  switch (style) {
+    case 'form':
+      return ','
+    case 'pipeDelimited':
+      return '|'
+    case 'spaceDelimited':
+      return '%20'
+    default:
+      return ','
+  }
+}
+
+export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
+  switch (style) {
+    case 'label':
+      return '.'
+    case 'matrix':
+      return ';'
+    case 'simple':
+      return ','
+    default:
+      return '&'
+  }
+}
+
+export const serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}: SerializeOptions<ArraySeparatorStyle> & {
+  value: unknown[]
+}) => {
+  if (!explode) {
+    const joinedValues = (
+      allowReserved ? value : value.map((v) => encodeURIComponent(v as string))
+    ).join(separatorArrayNoExplode(style))
+    switch (style) {
+      case 'label':
+        return `.${joinedValues}`
+      case 'matrix':
+        return `;${name}=${joinedValues}`
+      case 'simple':
+        return joinedValues
+      default:
+        return `${name}=${joinedValues}`
+    }
+  }
+
+  const separator = separatorArrayExplode(style)
+  const joinedValues = value
+    .map((v) => {
+      if (style === 'label' || style === 'simple') {
+        return allowReserved ? v : encodeURIComponent(v as string)
+      }
+
+      return serializePrimitiveParam({
+        allowReserved,
+        name,
+        value: v as string
+      })
+    })
+    .join(separator)
+  return style === 'label' || style === 'matrix' ? separator + joinedValues : joinedValues
+}
+
+export const serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}: SerializePrimitiveParam) => {
+  if (value === undefined || value === null) {
+    return ''
+  }
+
+  if (typeof value === 'object') {
+    throw new Error(
+      'Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.'
+    )
+  }
+
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`
+}
+
+export const serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}: SerializeOptions<ObjectSeparatorStyle> & {
+  value: Record<string, unknown> | Date
+  valueOnly?: boolean
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`
+  }
+
+  if (style !== 'deepObject' && !explode) {
+    let values: string[] = []
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? (v as string) : encodeURIComponent(v as string)]
+    })
+    const joinedValues = values.join(',')
+    switch (style) {
+      case 'form':
+        return `${name}=${joinedValues}`
+      case 'label':
+        return `.${joinedValues}`
+      case 'matrix':
+        return `;${name}=${joinedValues}`
+      default:
+        return joinedValues
+    }
+  }
+
+  const separator = separatorObjectExplode(style)
+  const joinedValues = Object.entries(value)
+    .map(([key, v]) =>
+      serializePrimitiveParam({
+        allowReserved,
+        name: style === 'deepObject' ? `${name}[${key}]` : key,
+        value: v as string
+      })
+    )
+    .join(separator)
+  return style === 'label' || style === 'matrix' ? separator + joinedValues : joinedValues
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/serverSentEvents.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/serverSentEvents.gen.ts
new file mode 100644
index 000000000..de07ebaf2
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/serverSentEvents.gen.ts
@@ -0,0 +1,214 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Config } from './types.gen'
+
+export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> &
+  Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>
+    url: string
+  }
+
+export interface StreamEvent<TData = unknown> {
+  data: TData
+  event?: string
+  id?: string
+  retry?: number
+}
+
+export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+  stream: AsyncGenerator<
+    TData extends Record<string, unknown> ? TData[keyof TData] : TData,
+    TReturn,
+    TNext
+  >
+}
+
+export const createSseClient = <TData = unknown>({
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}: ServerSentEventsOptions): ServerSentEventsResult<TData> => {
+  let lastEventId: string | undefined
+
+  const sleep = sseSleepFn ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)))
+
+  const createStream = async function* () {
+    let retryDelay: number = sseDefaultRetryDelay ?? 3000
+    let attempt = 0
+    const signal = options.signal ?? new AbortController().signal
+
+    while (true) {
+      if (signal.aborted) break
+
+      attempt++
+
+      const headers =
+        options.headers instanceof Headers
+          ? options.headers
+          : new Headers(options.headers as Record<string, string> | undefined)
+
+      if (lastEventId !== undefined) {
+        headers.set('Last-Event-ID', lastEventId)
+      }
+
+      try {
+        const response = await fetch(url, { ...options, headers, signal })
+
+        if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`)
+
+        if (!response.body) throw new Error('No body in SSE response')
+
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader()
+
+        let buffer = ''
+
+        const abortHandler = () => {
+          try {
+            reader.cancel()
+          } catch {
+            // noop
+          }
+        }
+
+        signal.addEventListener('abort', abortHandler)
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            buffer += value
+
+            const chunks = buffer.split('\n\n')
+            buffer = chunks.pop() ?? ''
+
+            for (const chunk of chunks) {
+              const lines = chunk.split('\n')
+              const dataLines: Array<string> = []
+              let eventName: string | undefined
+
+              for (const line of lines) {
+                if (line.startsWith('data:')) {
+                  dataLines.push(line.replace(/^data:\s*/, ''))
+                } else if (line.startsWith('event:')) {
+                  eventName = line.replace(/^event:\s*/, '')
+                } else if (line.startsWith('id:')) {
+                  lastEventId = line.replace(/^id:\s*/, '')
+                } else if (line.startsWith('retry:')) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ''), 10)
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed
+                  }
+                }
+              }
+
+              let data: unknown
+              let parsedJson = false
+
+              if (dataLines.length) {
+                const rawData = dataLines.join('\n')
+                try {
+                  data = JSON.parse(rawData)
+                  parsedJson = true
+                } catch {
+                  data = rawData
+                }
+              }
+
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data)
+                }
+
+                if (responseTransformer) {
+                  data = await responseTransformer(data)
+                }
+              }
+
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              })
+
+              if (dataLines.length) {
+                yield data as any
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener('abort', abortHandler)
+          reader.releaseLock()
+        }
+
+        break // exit loop on normal completion
+      } catch (error) {
+        // connection failed or aborted; retry after delay
+        onSseError?.(error)
+
+        if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+          break // stop after firing error
+        }
+
+        // exponential backoff: double retry each attempt, cap at 30s
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000)
+        await sleep(backoff)
+      }
+    }
+  }
+
+  const stream = createStream()
+
+  return { stream }
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/types.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/types.gen.ts
new file mode 100644
index 000000000..647ffcc49
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/types.gen.ts
@@ -0,0 +1,104 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth, AuthToken } from './auth.gen'
+import type { BodySerializer, QuerySerializer, QuerySerializerOptions } from './bodySerializer.gen'
+
+export type HttpMethod =
+  | 'connect'
+  | 'delete'
+  | 'get'
+  | 'head'
+  | 'options'
+  | 'patch'
+  | 'post'
+  | 'put'
+  | 'trace'
+
+export type Client<
+  RequestFn = never,
+  Config = unknown,
+  MethodFn = never,
+  BuildUrlFn = never,
+  SseFn = never
+> = {
+  /**
+   * Returns the final request URL.
+   */
+  buildUrl: BuildUrlFn
+  getConfig: () => Config
+  request: RequestFn
+  setConfig: (config: Config) => Config
+} & {
+  [K in HttpMethod]: MethodFn
+} & ([SseFn] extends [never] ? { sse?: never } : { sse: { [K in HttpMethod]: SseFn } })
+
+export interface Config {
+  /**
+   * Auth token or a function returning auth token. The resolved value will be
+   * added to the request payload as defined by its `security` array.
+   */
+  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken
+  /**
+   * A function for serializing request body parameter. By default,
+   * {@link JSON.stringify()} will be used.
+   */
+  bodySerializer?: BodySerializer | null
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+   */
+  headers?:
+    | RequestInit['headers']
+    | Record<
+        string,
+        string | number | boolean | (string | number | boolean)[] | null | undefined | unknown
+      >
+  /**
+   * The request method.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+   */
+  method?: Uppercase<HttpMethod>
+  /**
+   * A function for serializing request query parameters. By default, arrays
+   * will be exploded in form style, objects will be exploded in deepObject
+   * style, and reserved characters are percent-encoded.
+   *
+   * This method will have no effect if the native `paramsSerializer()` Axios
+   * API function is used.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer | QuerySerializerOptions
+  /**
+   * A function validating request data. This is useful if you want to ensure
+   * the request conforms to the desired shape, so it can be safely sent to
+   * the server.
+   */
+  requestValidator?: (data: unknown) => Promise<unknown>
+  /**
+   * A function transforming response data before it's returned. This is useful
+   * for post-processing data, e.g. converting ISO strings into Date objects.
+   */
+  responseTransformer?: (data: unknown) => Promise<unknown>
+  /**
+   * A function validating response data. This is useful if you want to ensure
+   * the response conforms to the desired shape, so it can be safely passed to
+   * the transformers and returned to the user.
+   */
+  responseValidator?: (data: unknown) => Promise<unknown>
+}
+
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
+  ? true
+  : [T] extends [never | undefined]
+    ? [undefined] extends [T]
+      ? false
+      : true
+    : false
+
+export type OmitNever<T extends Record<string, unknown>> = {
+  [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K]
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/core/utils.gen.ts b/examples/openapi-ts-pinia-colada/src/client/core/utils.gen.ts
new file mode 100644
index 000000000..b99c527aa
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/core/utils.gen.ts
@@ -0,0 +1,111 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { QuerySerializer } from './bodySerializer.gen'
+import {
+  type ArraySeparatorStyle,
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam
+} from './pathSerializer.gen'
+
+export interface PathSerializer {
+  path: Record<string, unknown>
+  url: string
+}
+
+export const PATH_PARAM_RE = /\{[^{}]+\}/g
+
+export const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
+  let url = _url
+  const matches = _url.match(PATH_PARAM_RE)
+  if (matches) {
+    for (const match of matches) {
+      let explode = false
+      let name = match.substring(1, match.length - 1)
+      let style: ArraySeparatorStyle = 'simple'
+
+      if (name.endsWith('*')) {
+        explode = true
+        name = name.substring(0, name.length - 1)
+      }
+
+      if (name.startsWith('.')) {
+        name = name.substring(1)
+        style = 'label'
+      } else if (name.startsWith(';')) {
+        name = name.substring(1)
+        style = 'matrix'
+      }
+
+      const value = path[name]
+
+      if (value === undefined || value === null) {
+        continue
+      }
+
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }))
+        continue
+      }
+
+      if (typeof value === 'object') {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value: value as Record<string, unknown>,
+            valueOnly: true
+          })
+        )
+        continue
+      }
+
+      if (style === 'matrix') {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value: value as string
+          })}`
+        )
+        continue
+      }
+
+      const replaceValue = encodeURIComponent(
+        style === 'label' ? `.${value as string}` : (value as string)
+      )
+      url = url.replace(match, replaceValue)
+    }
+  }
+  return url
+}
+
+export const getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}: {
+  baseUrl?: string
+  path?: Record<string, unknown>
+  query?: Record<string, unknown>
+  querySerializer: QuerySerializer
+  url: string
+}) => {
+  const pathUrl = _url.startsWith('/') ? _url : `/${_url}`
+  let url = (baseUrl ?? '') + pathUrl
+  if (path) {
+    url = defaultPathSerializer({ path, url })
+  }
+  let search = query ? querySerializer(query) : ''
+  if (search.startsWith('?')) {
+    search = search.substring(1)
+  }
+  if (search) {
+    url += `?${search}`
+  }
+  return url
+}
diff --git a/examples/openapi-ts-pinia-colada/src/client/index.ts b/examples/openapi-ts-pinia-colada/src/client/index.ts
new file mode 100644
index 000000000..2543e5750
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/index.ts
@@ -0,0 +1,4 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './@pinia/colada.gen'
+export * from './sdk.gen'
+export * from './types.gen'
diff --git a/examples/openapi-ts-pinia-colada/src/client/schemas.gen.ts b/examples/openapi-ts-pinia-colada/src/client/schemas.gen.ts
new file mode 100644
index 000000000..872554d20
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/schemas.gen.ts
@@ -0,0 +1,188 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export const OrderSchema = {
+  properties: {
+    complete: {
+      type: 'boolean'
+    },
+    id: {
+      example: 10,
+      format: 'int64',
+      type: 'integer'
+    },
+    petId: {
+      example: 198772,
+      format: 'int64',
+      type: 'integer'
+    },
+    quantity: {
+      example: 7,
+      format: 'int32',
+      type: 'integer'
+    },
+    shipDate: {
+      format: 'date-time',
+      type: 'string'
+    },
+    status: {
+      description: 'Order Status',
+      enum: ['placed', 'approved', 'delivered'],
+      example: 'approved',
+      type: 'string'
+    }
+  },
+  type: 'object',
+  'x-swagger-router-model': 'io.swagger.petstore.model.Order',
+  xml: {
+    name: 'order'
+  }
+} as const
+
+export const CategorySchema = {
+  properties: {
+    id: {
+      example: 1,
+      format: 'int64',
+      type: 'integer'
+    },
+    name: {
+      example: 'Dogs',
+      type: 'string'
+    }
+  },
+  type: 'object',
+  'x-swagger-router-model': 'io.swagger.petstore.model.Category',
+  xml: {
+    name: 'category'
+  }
+} as const
+
+export const UserSchema = {
+  properties: {
+    email: {
+      example: 'john@email.com',
+      type: 'string'
+    },
+    firstName: {
+      example: 'John',
+      type: 'string'
+    },
+    id: {
+      example: 10,
+      format: 'int64',
+      type: 'integer'
+    },
+    lastName: {
+      example: 'James',
+      type: 'string'
+    },
+    password: {
+      example: '12345',
+      type: 'string'
+    },
+    phone: {
+      example: '12345',
+      type: 'string'
+    },
+    userStatus: {
+      description: 'User Status',
+      example: 1,
+      format: 'int32',
+      type: 'integer'
+    },
+    username: {
+      example: 'theUser',
+      type: 'string'
+    }
+  },
+  type: 'object',
+  'x-swagger-router-model': 'io.swagger.petstore.model.User',
+  xml: {
+    name: 'user'
+  }
+} as const
+
+export const TagSchema = {
+  properties: {
+    id: {
+      format: 'int64',
+      type: 'integer'
+    },
+    name: {
+      type: 'string'
+    }
+  },
+  type: 'object',
+  'x-swagger-router-model': 'io.swagger.petstore.model.Tag',
+  xml: {
+    name: 'tag'
+  }
+} as const
+
+export const PetSchema = {
+  properties: {
+    category: {
+      $ref: '#/components/schemas/Category'
+    },
+    id: {
+      example: 10,
+      format: 'int64',
+      type: 'integer'
+    },
+    name: {
+      example: 'doggie',
+      type: 'string'
+    },
+    photoUrls: {
+      items: {
+        type: 'string',
+        xml: {
+          name: 'photoUrl'
+        }
+      },
+      type: 'array',
+      xml: {
+        wrapped: true
+      }
+    },
+    status: {
+      description: 'pet status in the store',
+      enum: ['available', 'pending', 'sold'],
+      type: 'string'
+    },
+    tags: {
+      items: {
+        $ref: '#/components/schemas/Tag'
+      },
+      type: 'array',
+      xml: {
+        wrapped: true
+      }
+    }
+  },
+  required: ['name', 'photoUrls'],
+  type: 'object',
+  'x-swagger-router-model': 'io.swagger.petstore.model.Pet',
+  xml: {
+    name: 'pet'
+  }
+} as const
+
+export const ApiResponseSchema = {
+  properties: {
+    code: {
+      format: 'int32',
+      type: 'integer'
+    },
+    message: {
+      type: 'string'
+    },
+    type: {
+      type: 'string'
+    }
+  },
+  type: 'object',
+  xml: {
+    name: '##default'
+  }
+} as const
diff --git a/examples/openapi-ts-pinia-colada/src/client/sdk.gen.ts b/examples/openapi-ts-pinia-colada/src/client/sdk.gen.ts
new file mode 100644
index 000000000..f373c7cf6
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/sdk.gen.ts
@@ -0,0 +1,411 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Options as ClientOptions, TDataShape } from './client'
+import { client as _heyApiClient } from './client.gen'
+import type {
+  AddPetData,
+  AddPetErrors,
+  AddPetResponses,
+  CreateUserData,
+  CreateUserErrors,
+  CreateUserResponses,
+  CreateUsersWithListInputData,
+  CreateUsersWithListInputErrors,
+  CreateUsersWithListInputResponses,
+  DeleteOrderData,
+  DeleteOrderErrors,
+  DeleteOrderResponses,
+  DeletePetData,
+  DeletePetErrors,
+  DeletePetResponses,
+  DeleteUserData,
+  DeleteUserErrors,
+  DeleteUserResponses,
+  FindPetsByStatusData,
+  FindPetsByStatusErrors,
+  FindPetsByStatusResponses,
+  FindPetsByTagsData,
+  FindPetsByTagsErrors,
+  FindPetsByTagsResponses,
+  GetInventoryData,
+  GetInventoryErrors,
+  GetInventoryResponses,
+  GetOrderByIdData,
+  GetOrderByIdErrors,
+  GetOrderByIdResponses,
+  GetPetByIdData,
+  GetPetByIdErrors,
+  GetPetByIdResponses,
+  GetUserByNameData,
+  GetUserByNameErrors,
+  GetUserByNameResponses,
+  LoginUserData,
+  LoginUserErrors,
+  LoginUserResponses,
+  LogoutUserData,
+  LogoutUserErrors,
+  LogoutUserResponses,
+  PlaceOrderData,
+  PlaceOrderErrors,
+  PlaceOrderResponses,
+  UpdatePetData,
+  UpdatePetErrors,
+  UpdatePetResponses,
+  UpdatePetWithFormData,
+  UpdatePetWithFormErrors,
+  UpdatePetWithFormResponses,
+  UpdateUserData,
+  UpdateUserErrors,
+  UpdateUserResponses,
+  UploadFileData,
+  UploadFileErrors,
+  UploadFileResponses
+} from './types.gen'
+
+export type Options<
+  TData extends TDataShape = TDataShape,
+  ThrowOnError extends boolean = boolean
+> = ClientOptions<TData, ThrowOnError> & {
+  /**
+   * You can provide a client instance returned by `createClient()` instead of
+   * individual options. This might be also useful if you want to implement a
+   * custom client.
+   */
+  client?: Client
+  /**
+   * You can pass arbitrary values through the `meta` object. This can be
+   * used to access values that aren't defined as part of the SDK function.
+   */
+  meta?: Record<string, unknown>
+}
+
+/**
+ * Add a new pet to the store.
+ * Add a new pet to the store.
+ */
+export const addPet = <ThrowOnError extends boolean = false>(
+  options: Options<AddPetData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).post<AddPetResponses, AddPetErrors, ThrowOnError>({
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet',
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers
+    }
+  })
+
+/**
+ * Update an existing pet.
+ * Update an existing pet by Id.
+ */
+export const updatePet = <ThrowOnError extends boolean = false>(
+  options: Options<UpdatePetData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).put<UpdatePetResponses, UpdatePetErrors, ThrowOnError>({
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet',
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers
+    }
+  })
+
+/**
+ * Finds Pets by status.
+ * Multiple status values can be provided with comma separated strings.
+ */
+export const findPetsByStatus = <ThrowOnError extends boolean = false>(
+  options: Options<FindPetsByStatusData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).get<
+    FindPetsByStatusResponses,
+    FindPetsByStatusErrors,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet/findByStatus',
+    ...options
+  })
+
+/**
+ * Finds Pets by tags.
+ * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ */
+export const findPetsByTags = <ThrowOnError extends boolean = false>(
+  options: Options<FindPetsByTagsData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).get<
+    FindPetsByTagsResponses,
+    FindPetsByTagsErrors,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet/findByTags',
+    ...options
+  })
+
+/**
+ * Deletes a pet.
+ * Delete a pet.
+ */
+export const deletePet = <ThrowOnError extends boolean = false>(
+  options: Options<DeletePetData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).delete<DeletePetResponses, DeletePetErrors, ThrowOnError>({
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet/{petId}',
+    ...options
+  })
+
+/**
+ * Find pet by ID.
+ * Returns a single pet.
+ */
+export const getPetById = <ThrowOnError extends boolean = false>(
+  options: Options<GetPetByIdData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).get<GetPetByIdResponses, GetPetByIdErrors, ThrowOnError>({
+    security: [
+      {
+        name: 'api_key',
+        type: 'apiKey'
+      },
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet/{petId}',
+    ...options
+  })
+
+/**
+ * Updates a pet in the store with form data.
+ * Updates a pet resource based on the form data.
+ */
+export const updatePetWithForm = <ThrowOnError extends boolean = false>(
+  options: Options<UpdatePetWithFormData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).post<
+    UpdatePetWithFormResponses,
+    UpdatePetWithFormErrors,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet/{petId}',
+    ...options
+  })
+
+/**
+ * Uploads an image.
+ * Upload image of the pet.
+ */
+export const uploadFile = <ThrowOnError extends boolean = false>(
+  options: Options<UploadFileData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).post<UploadFileResponses, UploadFileErrors, ThrowOnError>({
+    bodySerializer: null,
+    security: [
+      {
+        scheme: 'bearer',
+        type: 'http'
+      }
+    ],
+    url: '/pet/{petId}/uploadImage',
+    ...options,
+    headers: {
+      'Content-Type': 'application/octet-stream',
+      ...options.headers
+    }
+  })
+
+/**
+ * Returns pet inventories by status.
+ * Returns a map of status codes to quantities.
+ */
+export const getInventory = <ThrowOnError extends boolean = false>(
+  options?: Options<GetInventoryData, ThrowOnError>
+) =>
+  (options?.client ?? _heyApiClient).get<GetInventoryResponses, GetInventoryErrors, ThrowOnError>({
+    security: [
+      {
+        name: 'api_key',
+        type: 'apiKey'
+      }
+    ],
+    url: '/store/inventory',
+    ...options
+  })
+
+/**
+ * Place an order for a pet.
+ * Place a new order in the store.
+ */
+export const placeOrder = <ThrowOnError extends boolean = false>(
+  options?: Options<PlaceOrderData, ThrowOnError>
+) =>
+  (options?.client ?? _heyApiClient).post<PlaceOrderResponses, PlaceOrderErrors, ThrowOnError>({
+    url: '/store/order',
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options?.headers
+    }
+  })
+
+/**
+ * Delete purchase order by identifier.
+ * For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.
+ */
+export const deleteOrder = <ThrowOnError extends boolean = false>(
+  options: Options<DeleteOrderData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).delete<DeleteOrderResponses, DeleteOrderErrors, ThrowOnError>({
+    url: '/store/order/{orderId}',
+    ...options
+  })
+
+/**
+ * Find purchase order by ID.
+ * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.
+ */
+export const getOrderById = <ThrowOnError extends boolean = false>(
+  options: Options<GetOrderByIdData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).get<GetOrderByIdResponses, GetOrderByIdErrors, ThrowOnError>({
+    url: '/store/order/{orderId}',
+    ...options
+  })
+
+/**
+ * Create user.
+ * This can only be done by the logged in user.
+ */
+export const createUser = <ThrowOnError extends boolean = false>(
+  options?: Options<CreateUserData, ThrowOnError>
+) =>
+  (options?.client ?? _heyApiClient).post<CreateUserResponses, CreateUserErrors, ThrowOnError>({
+    url: '/user',
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options?.headers
+    }
+  })
+
+/**
+ * Creates list of users with given input array.
+ * Creates list of users with given input array.
+ */
+export const createUsersWithListInput = <ThrowOnError extends boolean = false>(
+  options?: Options<CreateUsersWithListInputData, ThrowOnError>
+) =>
+  (options?.client ?? _heyApiClient).post<
+    CreateUsersWithListInputResponses,
+    CreateUsersWithListInputErrors,
+    ThrowOnError
+  >({
+    url: '/user/createWithList',
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options?.headers
+    }
+  })
+
+/**
+ * Logs user into the system.
+ * Log into the system.
+ */
+export const loginUser = <ThrowOnError extends boolean = false>(
+  options?: Options<LoginUserData, ThrowOnError>
+) =>
+  (options?.client ?? _heyApiClient).get<LoginUserResponses, LoginUserErrors, ThrowOnError>({
+    url: '/user/login',
+    ...options
+  })
+
+/**
+ * Logs out current logged in user session.
+ * Log user out of the system.
+ */
+export const logoutUser = <ThrowOnError extends boolean = false>(
+  options?: Options<LogoutUserData, ThrowOnError>
+) =>
+  (options?.client ?? _heyApiClient).get<LogoutUserResponses, LogoutUserErrors, ThrowOnError>({
+    url: '/user/logout',
+    ...options
+  })
+
+/**
+ * Delete user resource.
+ * This can only be done by the logged in user.
+ */
+export const deleteUser = <ThrowOnError extends boolean = false>(
+  options: Options<DeleteUserData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).delete<DeleteUserResponses, DeleteUserErrors, ThrowOnError>({
+    url: '/user/{username}',
+    ...options
+  })
+
+/**
+ * Get user by user name.
+ * Get user detail based on username.
+ */
+export const getUserByName = <ThrowOnError extends boolean = false>(
+  options: Options<GetUserByNameData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).get<GetUserByNameResponses, GetUserByNameErrors, ThrowOnError>({
+    url: '/user/{username}',
+    ...options
+  })
+
+/**
+ * Update user resource.
+ * This can only be done by the logged in user.
+ */
+export const updateUser = <ThrowOnError extends boolean = false>(
+  options: Options<UpdateUserData, ThrowOnError>
+) =>
+  (options.client ?? _heyApiClient).put<UpdateUserResponses, UpdateUserErrors, ThrowOnError>({
+    url: '/user/{username}',
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers
+    }
+  })
diff --git a/examples/openapi-ts-pinia-colada/src/client/types.gen.ts b/examples/openapi-ts-pinia-colada/src/client/types.gen.ts
new file mode 100644
index 000000000..f7044e662
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/client/types.gen.ts
@@ -0,0 +1,693 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type Order = {
+  complete?: boolean
+  id?: number
+  petId?: number
+  quantity?: number
+  shipDate?: string
+  /**
+   * Order Status
+   */
+  status?: 'placed' | 'approved' | 'delivered'
+}
+
+export type Category = {
+  id?: number
+  name?: string
+}
+
+export type User = {
+  email?: string
+  firstName?: string
+  id?: number
+  lastName?: string
+  password?: string
+  phone?: string
+  /**
+   * User Status
+   */
+  userStatus?: number
+  username?: string
+}
+
+export type Tag = {
+  id?: number
+  name?: string
+}
+
+export type Pet = {
+  category?: Category
+  id?: number
+  name: string
+  photoUrls: Array<string>
+  /**
+   * pet status in the store
+   */
+  status?: 'available' | 'pending' | 'sold'
+  tags?: Array<Tag>
+}
+
+export type ApiResponse = {
+  code?: number
+  message?: string
+  type?: string
+}
+
+export type Pet2 = Pet
+
+/**
+ * List of user object
+ */
+export type UserArray = Array<User>
+
+export type AddPetData = {
+  /**
+   * Create a new pet in the store
+   */
+  body: Pet
+  path?: never
+  query?: never
+  url: '/pet'
+}
+
+export type AddPetErrors = {
+  /**
+   * Invalid input
+   */
+  400: unknown
+  /**
+   * Validation exception
+   */
+  422: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type AddPetResponses = {
+  /**
+   * Successful operation
+   */
+  200: Pet
+}
+
+export type AddPetResponse = AddPetResponses[keyof AddPetResponses]
+
+export type UpdatePetData = {
+  /**
+   * Update an existent pet in the store
+   */
+  body: Pet
+  path?: never
+  query?: never
+  url: '/pet'
+}
+
+export type UpdatePetErrors = {
+  /**
+   * Invalid ID supplied
+   */
+  400: unknown
+  /**
+   * Pet not found
+   */
+  404: unknown
+  /**
+   * Validation exception
+   */
+  422: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type UpdatePetResponses = {
+  /**
+   * Successful operation
+   */
+  200: Pet
+}
+
+export type UpdatePetResponse = UpdatePetResponses[keyof UpdatePetResponses]
+
+export type FindPetsByStatusData = {
+  body?: never
+  path?: never
+  query: {
+    /**
+     * Status values that need to be considered for filter
+     */
+    status: 'available' | 'pending' | 'sold'
+  }
+  url: '/pet/findByStatus'
+}
+
+export type FindPetsByStatusErrors = {
+  /**
+   * Invalid status value
+   */
+  400: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type FindPetsByStatusResponses = {
+  /**
+   * successful operation
+   */
+  200: Array<Pet>
+}
+
+export type FindPetsByStatusResponse = FindPetsByStatusResponses[keyof FindPetsByStatusResponses]
+
+export type FindPetsByTagsData = {
+  body?: never
+  path?: never
+  query: {
+    /**
+     * Tags to filter by
+     */
+    tags: Array<string>
+  }
+  url: '/pet/findByTags'
+}
+
+export type FindPetsByTagsErrors = {
+  /**
+   * Invalid tag value
+   */
+  400: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type FindPetsByTagsResponses = {
+  /**
+   * successful operation
+   */
+  200: Array<Pet>
+}
+
+export type FindPetsByTagsResponse = FindPetsByTagsResponses[keyof FindPetsByTagsResponses]
+
+export type DeletePetData = {
+  body?: never
+  headers?: {
+    api_key?: string
+  }
+  path: {
+    /**
+     * Pet id to delete
+     */
+    petId: number
+  }
+  query?: never
+  url: '/pet/{petId}'
+}
+
+export type DeletePetErrors = {
+  /**
+   * Invalid pet value
+   */
+  400: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type DeletePetResponses = {
+  /**
+   * Pet deleted
+   */
+  200: unknown
+}
+
+export type GetPetByIdData = {
+  body?: never
+  path: {
+    /**
+     * ID of pet to return
+     */
+    petId: number
+  }
+  query?: never
+  url: '/pet/{petId}'
+}
+
+export type GetPetByIdErrors = {
+  /**
+   * Invalid ID supplied
+   */
+  400: unknown
+  /**
+   * Pet not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type GetPetByIdResponses = {
+  /**
+   * successful operation
+   */
+  200: Pet
+}
+
+export type GetPetByIdResponse = GetPetByIdResponses[keyof GetPetByIdResponses]
+
+export type UpdatePetWithFormData = {
+  body?: never
+  path: {
+    /**
+     * ID of pet that needs to be updated
+     */
+    petId: number
+  }
+  query?: {
+    /**
+     * Name of pet that needs to be updated
+     */
+    name?: string
+    /**
+     * Status of pet that needs to be updated
+     */
+    status?: string
+  }
+  url: '/pet/{petId}'
+}
+
+export type UpdatePetWithFormErrors = {
+  /**
+   * Invalid input
+   */
+  400: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type UpdatePetWithFormResponses = {
+  /**
+   * successful operation
+   */
+  200: Pet
+}
+
+export type UpdatePetWithFormResponse = UpdatePetWithFormResponses[keyof UpdatePetWithFormResponses]
+
+export type UploadFileData = {
+  body?: Blob | File
+  path: {
+    /**
+     * ID of pet to update
+     */
+    petId: number
+  }
+  query?: {
+    /**
+     * Additional Metadata
+     */
+    additionalMetadata?: string
+  }
+  url: '/pet/{petId}/uploadImage'
+}
+
+export type UploadFileErrors = {
+  /**
+   * No file uploaded
+   */
+  400: unknown
+  /**
+   * Pet not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type UploadFileResponses = {
+  /**
+   * successful operation
+   */
+  200: ApiResponse
+}
+
+export type UploadFileResponse = UploadFileResponses[keyof UploadFileResponses]
+
+export type GetInventoryData = {
+  body?: never
+  path?: never
+  query?: never
+  url: '/store/inventory'
+}
+
+export type GetInventoryErrors = {
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type GetInventoryResponses = {
+  /**
+   * successful operation
+   */
+  200: {
+    [key: string]: number
+  }
+}
+
+export type GetInventoryResponse = GetInventoryResponses[keyof GetInventoryResponses]
+
+export type PlaceOrderData = {
+  body?: Order
+  path?: never
+  query?: never
+  url: '/store/order'
+}
+
+export type PlaceOrderErrors = {
+  /**
+   * Invalid input
+   */
+  400: unknown
+  /**
+   * Validation exception
+   */
+  422: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type PlaceOrderResponses = {
+  /**
+   * successful operation
+   */
+  200: Order
+}
+
+export type PlaceOrderResponse = PlaceOrderResponses[keyof PlaceOrderResponses]
+
+export type DeleteOrderData = {
+  body?: never
+  path: {
+    /**
+     * ID of the order that needs to be deleted
+     */
+    orderId: number
+  }
+  query?: never
+  url: '/store/order/{orderId}'
+}
+
+export type DeleteOrderErrors = {
+  /**
+   * Invalid ID supplied
+   */
+  400: unknown
+  /**
+   * Order not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type DeleteOrderResponses = {
+  /**
+   * order deleted
+   */
+  200: unknown
+}
+
+export type GetOrderByIdData = {
+  body?: never
+  path: {
+    /**
+     * ID of order that needs to be fetched
+     */
+    orderId: number
+  }
+  query?: never
+  url: '/store/order/{orderId}'
+}
+
+export type GetOrderByIdErrors = {
+  /**
+   * Invalid ID supplied
+   */
+  400: unknown
+  /**
+   * Order not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type GetOrderByIdResponses = {
+  /**
+   * successful operation
+   */
+  200: Order
+}
+
+export type GetOrderByIdResponse = GetOrderByIdResponses[keyof GetOrderByIdResponses]
+
+export type CreateUserData = {
+  /**
+   * Created user object
+   */
+  body?: User
+  path?: never
+  query?: never
+  url: '/user'
+}
+
+export type CreateUserErrors = {
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type CreateUserResponses = {
+  /**
+   * successful operation
+   */
+  200: User
+}
+
+export type CreateUserResponse = CreateUserResponses[keyof CreateUserResponses]
+
+export type CreateUsersWithListInputData = {
+  body?: Array<User>
+  path?: never
+  query?: never
+  url: '/user/createWithList'
+}
+
+export type CreateUsersWithListInputErrors = {
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type CreateUsersWithListInputResponses = {
+  /**
+   * Successful operation
+   */
+  200: User
+}
+
+export type CreateUsersWithListInputResponse =
+  CreateUsersWithListInputResponses[keyof CreateUsersWithListInputResponses]
+
+export type LoginUserData = {
+  body?: never
+  path?: never
+  query?: {
+    /**
+     * The password for login in clear text
+     */
+    password?: string
+    /**
+     * The user name for login
+     */
+    username?: string
+  }
+  url: '/user/login'
+}
+
+export type LoginUserErrors = {
+  /**
+   * Invalid username/password supplied
+   */
+  400: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type LoginUserResponses = {
+  /**
+   * successful operation
+   */
+  200: string
+}
+
+export type LoginUserResponse = LoginUserResponses[keyof LoginUserResponses]
+
+export type LogoutUserData = {
+  body?: never
+  path?: never
+  query?: never
+  url: '/user/logout'
+}
+
+export type LogoutUserErrors = {
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type LogoutUserResponses = {
+  /**
+   * successful operation
+   */
+  200: unknown
+}
+
+export type DeleteUserData = {
+  body?: never
+  path: {
+    /**
+     * The name that needs to be deleted
+     */
+    username: string
+  }
+  query?: never
+  url: '/user/{username}'
+}
+
+export type DeleteUserErrors = {
+  /**
+   * Invalid username supplied
+   */
+  400: unknown
+  /**
+   * User not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type DeleteUserResponses = {
+  /**
+   * User deleted
+   */
+  200: unknown
+}
+
+export type GetUserByNameData = {
+  body?: never
+  path: {
+    /**
+     * The name that needs to be fetched. Use user1 for testing
+     */
+    username: string
+  }
+  query?: never
+  url: '/user/{username}'
+}
+
+export type GetUserByNameErrors = {
+  /**
+   * Invalid username supplied
+   */
+  400: unknown
+  /**
+   * User not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type GetUserByNameResponses = {
+  /**
+   * successful operation
+   */
+  200: User
+}
+
+export type GetUserByNameResponse = GetUserByNameResponses[keyof GetUserByNameResponses]
+
+export type UpdateUserData = {
+  /**
+   * Update an existent user in the store
+   */
+  body?: User
+  path: {
+    /**
+     * name that need to be deleted
+     */
+    username: string
+  }
+  query?: never
+  url: '/user/{username}'
+}
+
+export type UpdateUserErrors = {
+  /**
+   * bad request
+   */
+  400: unknown
+  /**
+   * user not found
+   */
+  404: unknown
+  /**
+   * Unexpected error
+   */
+  default: unknown
+}
+
+export type UpdateUserResponses = {
+  /**
+   * successful operation
+   */
+  200: unknown
+}
+
+export type ClientOptions = {
+  baseUrl: 'https://petstore3.swagger.io/api/v3' | (string & {})
+}
diff --git a/examples/openapi-ts-pinia-colada/src/main.ts b/examples/openapi-ts-pinia-colada/src/main.ts
new file mode 100644
index 000000000..e6089600f
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/main.ts
@@ -0,0 +1,28 @@
+import './assets/main.css'
+
+import { PiniaColada } from '@pinia/colada'
+import { createPinia } from 'pinia'
+import { createApp } from 'vue'
+
+import App from './App.vue'
+import { client } from './client/client.gen'
+import router from './router'
+
+// configure internal service client
+client.setConfig({
+  // set default base url for requests
+  baseUrl: 'https://petstore3.swagger.io/api/v3',
+  // set default headers for requests
+  headers: {
+    Authorization: 'Bearer <token_from_service_client>'
+  }
+})
+
+const app = createApp(App)
+
+const pinia = createPinia()
+app.use(pinia)
+app.use(PiniaColada)
+app.use(router)
+
+app.mount('#app')
diff --git a/examples/openapi-ts-pinia-colada/src/router/index.ts b/examples/openapi-ts-pinia-colada/src/router/index.ts
new file mode 100644
index 000000000..42ddd585a
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/router/index.ts
@@ -0,0 +1,16 @@
+import { createRouter, createWebHistory } from 'vue-router'
+
+import PiniaColadaExample from '@/views/PiniaColadaExample.vue'
+
+const router = createRouter({
+  history: createWebHistory(import.meta.env.BASE_URL),
+  routes: [
+    {
+      component: PiniaColadaExample,
+      name: 'home',
+      path: '/'
+    }
+  ]
+})
+
+export default router
diff --git a/examples/openapi-ts-pinia-colada/src/views/PiniaColadaExample.vue b/examples/openapi-ts-pinia-colada/src/views/PiniaColadaExample.vue
new file mode 100644
index 000000000..6930fc78a
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/src/views/PiniaColadaExample.vue
@@ -0,0 +1,221 @@
+<script lang="ts" setup>
+import type { Pet } from '@/client'
+import { createClient } from '@/client/client'
+import { PetSchema } from '@/client/schemas.gen'
+import { addPetMutation, getPetByIdQuery, updatePetMutation } from '@/client/@pinia/colada.gen'
+import { useQuery, useMutation } from '@pinia/colada'
+import { ref, watch } from 'vue'
+import type { RequestOptions } from '@/client/client'
+
+const localClient = createClient({
+  // set default base url for requests made by this client
+  baseUrl: 'https://petstore3.swagger.io/api/v3',
+  /**
+   * Set default headers only for requests made by this client. This is to
+   * demonstrate local clients and their configuration taking precedence over
+   * internal service client.
+   */
+  headers: {
+    Authorization: 'Bearer <token_from_local_client>'
+  }
+})
+
+localClient.interceptors.request.use((request: Request, options: RequestOptions) => {
+  // Middleware is great for adding authorization tokens to requests made to
+  // protected paths. Headers are set randomly here to allow surfacing the
+  // default headers, too.
+  if (options.url === '/pet/{petId}' && options.method === 'GET' && Math.random() < 0.5) {
+    request.headers.set('Authorization', 'Bearer <token_from_interceptor>')
+  }
+  return request
+})
+
+const pet = ref<Pet>()
+const petId = ref<number>()
+
+const petInput = ref({ name: '', category: '' })
+
+const addPet = useMutation(addPetMutation())
+
+const updatePet = useMutation(updatePetMutation())
+
+const { data, error } = useQuery(() => {
+  if (!petId.value) {
+    return {
+      key: ['getPetById', 'none'],
+      query: async () => undefined,
+      enabled: false
+    }
+  }
+
+  return {
+    ...getPetByIdQuery({
+      client: localClient,
+      path: {
+        petId: petId.value
+      }
+    }),
+    enabled: true
+  }
+})
+
+const handleAddPet = async () => {
+  if (PetSchema.required.includes('name') && !petInput.value?.name?.length) {
+    return
+  }
+
+  const result = await addPet.mutateAsync({
+    body: {
+      category: {
+        id: 0,
+        name: petInput.value.category
+      },
+      id: 0,
+      name: petInput.value?.name,
+      photoUrls: ['string'],
+      status: 'available',
+      tags: [
+        {
+          id: 0,
+          name: 'string'
+        }
+      ]
+    }
+  })
+
+  if (result) {
+    pet.value = result
+    petId.value = result.id ?? petId.value
+  }
+}
+
+function setRandomPetId() {
+  // random id 1-10
+  petId.value = Math.floor(Math.random() * (10 - 1 + 1) + 1)
+}
+
+const handleUpdatePet = async () => {
+  const result = await updatePet.mutateAsync({
+    body: {
+      category: {
+        id: pet.value?.category?.id ?? 0,
+        name: petInput.value.category
+      },
+      id: pet.value?.id ?? 0,
+      name: petInput.value.name,
+      photoUrls: ['string'],
+      status: 'available',
+      tags: [
+        {
+          id: 0,
+          name: 'string'
+        }
+      ]
+    },
+    // setting headers per request
+    headers: {
+      Authorization: 'Bearer <token_from_method>'
+    }
+  })
+
+  if (result) {
+    pet.value = result
+    petId.value = result.id ?? petId.value
+  }
+}
+
+watch(data, () => {
+  pet.value = data.value as Pet | undefined
+})
+
+watch(error, (error) => {
+  console.log(error)
+})
+</script>
+
+<template>
+  <div class="bg-[#18191b] py-12">
+    <div class="mx-auto flex max-w-md flex-col gap-12">
+      <div class="flex items-center">
+        <a class="shrink-0" href="https://heyapi.dev/" target="_blank">
+          <img
+            alt="Hey API logo"
+            class="size-16 transition duration-300 will-change-auto"
+            src="https://heyapi.dev/logo.png"
+          />
+        </a>
+
+        <h1 class="text-2xl font-bold text-white">@hey-api/openapi-ts 🤝 Pinia Colada</h1>
+      </div>
+
+      <div class="flex flex-col gap-2">
+        <div
+          class="flex max-w-60 items-center gap-3 rounded border border-[#575e64] bg-[#1f2123] p-4"
+        >
+          <div
+            class="flex size-10 place-content-center place-items-center rounded-full bg-[#233057] text-lg font-medium text-[#9eb1ff]"
+          >
+            <span>
+              {{ pet?.name?.slice(0, 1) || 'N' }}
+            </span>
+          </div>
+
+          <div>
+            <p class="text-sm font-bold text-white">Name: {{ pet?.name || 'N/A' }}</p>
+
+            <p class="text-sm text-[#f1f7feb5]">Category: {{ pet?.category?.name || 'N/A' }}</p>
+          </div>
+        </div>
+
+        <button
+          class="rounded bg-[#3e63dd] p-1 text-sm font-medium text-white"
+          type="button"
+          @click="setRandomPetId"
+        >
+          Get Random Pet
+        </button>
+      </div>
+
+      <form class="flex flex-col gap-3" @submit.prevent="handleAddPet">
+        <div class="flex w-64 flex-col gap-1">
+          <label class="font-medium text-white" for="name">Name</label>
+
+          <input
+            v-model="petInput.name"
+            class="rounded border border-[#575e64] bg-[#121314] p-1 text-sm text-white placeholder:text-[#575e64]"
+            name="name"
+            placeholder="Kitty"
+            required
+          />
+        </div>
+
+        <div class="flex w-64 flex-col gap-1">
+          <label class="font-medium text-white" for="category">Category</label>
+
+          <input
+            v-model="petInput.category"
+            class="rounded border border-[#575e64] bg-[#121314] p-1 text-sm text-white placeholder:text-[#575e64]"
+            name="category"
+            placeholder="Cats"
+            required
+          />
+        </div>
+
+        <div class="flex gap-2">
+          <button class="rounded bg-[#3e63dd] p-2 text-sm font-medium text-white" type="submit">
+            Add Pet
+          </button>
+
+          <button
+            class="rounded bg-[#3e63dd] p-2 text-sm font-medium text-white disabled:cursor-not-allowed"
+            :disabled="!pet"
+            type="button"
+            @click="handleUpdatePet"
+          >
+            Update Pet
+          </button>
+        </div>
+      </form>
+    </div>
+  </div>
+</template>
diff --git a/examples/openapi-ts-pinia-colada/tailwind.config.ts b/examples/openapi-ts-pinia-colada/tailwind.config.ts
new file mode 100644
index 000000000..8cb3cc6c0
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/tailwind.config.ts
@@ -0,0 +1,9 @@
+import type { Config } from 'tailwindcss'
+
+export default {
+  content: ['./index.html', './src/**/*.{vue,js,ts,jsx,tsx}'],
+  plugins: [],
+  theme: {
+    extend: {}
+  }
+} satisfies Config
diff --git a/examples/openapi-ts-pinia-colada/tsconfig.app.json b/examples/openapi-ts-pinia-colada/tsconfig.app.json
new file mode 100644
index 000000000..81efb53e9
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/tsconfig.app.json
@@ -0,0 +1,14 @@
+{
+  "extends": "@vue/tsconfig/tsconfig.dom.json",
+  "include": ["./env.d.ts", "./src/**/*", "./src/**/*.vue"],
+  "exclude": ["./src/**/__tests__/*"],
+  "compilerOptions": {
+    "composite": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}
diff --git a/examples/openapi-ts-pinia-colada/tsconfig.json b/examples/openapi-ts-pinia-colada/tsconfig.json
new file mode 100644
index 000000000..100cf6a8f
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.node.json"
+    },
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.vitest.json"
+    }
+  ]
+}
diff --git a/examples/openapi-ts-pinia-colada/tsconfig.node.json b/examples/openapi-ts-pinia-colada/tsconfig.node.json
new file mode 100644
index 000000000..f09406303
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/tsconfig.node.json
@@ -0,0 +1,19 @@
+{
+  "extends": "@tsconfig/node20/tsconfig.json",
+  "include": [
+    "vite.config.*",
+    "vitest.config.*",
+    "cypress.config.*",
+    "nightwatch.conf.*",
+    "playwright.config.*"
+  ],
+  "compilerOptions": {
+    "composite": true,
+    "noEmit": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "types": ["node"]
+  }
+}
diff --git a/examples/openapi-ts-pinia-colada/tsconfig.vitest.json b/examples/openapi-ts-pinia-colada/tsconfig.vitest.json
new file mode 100644
index 000000000..571995d11
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/tsconfig.vitest.json
@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.app.json",
+  "exclude": [],
+  "compilerOptions": {
+    "composite": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.vitest.tsbuildinfo",
+
+    "lib": [],
+    "types": ["node", "jsdom"]
+  }
+}
diff --git a/examples/openapi-ts-pinia-colada/vite.config.ts b/examples/openapi-ts-pinia-colada/vite.config.ts
new file mode 100644
index 000000000..2ad0b1736
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/vite.config.ts
@@ -0,0 +1,16 @@
+import { fileURLToPath, URL } from 'node:url'
+
+import { createViteConfig } from '@config/vite-base'
+import vue from '@vitejs/plugin-vue'
+import vueJsx from '@vitejs/plugin-vue-jsx'
+import vueDevTools from 'vite-plugin-vue-devtools'
+
+// https://vitejs.dev/config/
+export default createViteConfig({
+  plugins: [vue(), vueJsx(), vueDevTools()],
+  resolve: {
+    alias: {
+      '@': fileURLToPath(new URL('./src', import.meta.url))
+    }
+  }
+})
diff --git a/examples/openapi-ts-pinia-colada/vitest.config.ts b/examples/openapi-ts-pinia-colada/vitest.config.ts
new file mode 100644
index 000000000..b1c1888c6
--- /dev/null
+++ b/examples/openapi-ts-pinia-colada/vitest.config.ts
@@ -0,0 +1,16 @@
+import { fileURLToPath } from 'node:url'
+
+import { createVitestConfig } from '@config/vite-base'
+import { configDefaults, mergeConfig } from 'vitest/config'
+
+import viteConfig from './vite.config'
+
+export default mergeConfig(
+  viteConfig,
+  createVitestConfig(fileURLToPath(new URL('./', import.meta.url)), {
+    test: {
+      environment: 'jsdom',
+      exclude: [...configDefaults.exclude, 'e2e/**']
+    }
+  })
+)
diff --git a/package.json b/package.json
index beb4c7320..a4e89921c 100644
--- a/package.json
+++ b/package.json
@@ -61,7 +61,7 @@
     "rollup": "4.31.0",
     "rollup-plugin-dts": "6.1.1",
     "tsup": "8.4.0",
-    "turbo": "2.5.5",
+    "turbo": "2.5.6",
     "typescript": "5.8.3",
     "typescript-eslint": "8.29.1",
     "vitest": "3.1.1"
diff --git a/packages/openapi-ts-tests/main/package.json b/packages/openapi-ts-tests/main/package.json
index 738d48de5..f2bf8fa5f 100644
--- a/packages/openapi-ts-tests/main/package.json
+++ b/packages/openapi-ts-tests/main/package.json
@@ -34,6 +34,7 @@
     "@config/vite-base": "workspace:*",
     "@hey-api/custom-client": "workspace:*",
     "@hey-api/openapi-ts": "workspace:*",
+    "@pinia/colada": "0.17.2",
     "@tanstack/angular-query-experimental": "5.73.3",
     "@tanstack/react-query": "5.73.3",
     "@tanstack/solid-query": "5.73.3",
diff --git a/packages/openapi-ts-tests/main/test/3.1.x.test.ts b/packages/openapi-ts-tests/main/test/3.1.x.test.ts
index 3dfb21499..d0b59cb13 100644
--- a/packages/openapi-ts-tests/main/test/3.1.x.test.ts
+++ b/packages/openapi-ts-tests/main/test/3.1.x.test.ts
@@ -815,6 +815,151 @@ describe(`OpenAPI ${version}`, () => {
       description:
         'generates validator schemas for all integer format combinations (number/integer/string types with int8, int16, int32, int64, uint8, uint16, uint32, uint64 formats)',
     },
+    // TODO: add Pinia Colada snapshots
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/default',
+    //     plugins: ['@pinia/colada'],
+    //   }),
+    //   description: 'generates Pinia Colada plugin code with default settings',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/operationOverrides',
+    //     plugins: [
+    //       {
+    //         name: '@pinia/colada',
+    //         operationTypes: {
+    //           addPet: 'query',
+    //           getPetById: 'both',
+    //         },
+    //       },
+    //     ],
+    //   }),
+    //   description:
+    //     'generates Pinia Colada plugin code with operation type overrides',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/groupByTag',
+    //     plugins: [
+    //       {
+    //         groupByTag: true,
+    //         name: '@pinia/colada',
+    //       },
+    //     ],
+    //   }),
+    //   description: 'generates Pinia Colada plugin code grouped by OpenAPI tags',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/groupByTagWithIndex',
+    //     plugins: [
+    //       {
+    //         exportFromIndex: true,
+    //         groupByTag: true,
+    //         name: '@pinia/colada',
+    //       },
+    //     ],
+    //   }),
+    //   description:
+    //     'generates Pinia Colada plugin code grouped by tags with index file',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/customNaming',
+    //     plugins: [
+    //       {
+    //         mutationOptions: {
+    //           name: '{{name}}MutationOptions',
+    //         },
+    //         name: '@pinia/colada',
+    //         queryOptions: {
+    //           name: '{{name}}QueryOptions',
+    //         },
+    //       },
+    //     ],
+    //   }),
+    //   description:
+    //     'generates Pinia Colada plugin code with custom naming patterns',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/caseSettings',
+    //     plugins: [
+    //       {
+    //         case: 'PascalCase',
+    //         mutationOptions: {
+    //           case: 'snake_case',
+    //         },
+    //         name: '@pinia/colada',
+    //         queryOptions: {
+    //           case: 'camelCase',
+    //         },
+    //       },
+    //     ],
+    //   }),
+    //   description:
+    //     'generates Pinia Colada plugin code with different case settings',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/disabledOptions',
+    //     plugins: [
+    //       {
+    //         mutationOptions: {
+    //           enabled: true,
+    //         },
+    //         name: '@pinia/colada',
+    //         queryOptions: false,
+    //       },
+    //     ],
+    //   }),
+    //   description: 'generates Pinia Colada plugin code with queries disabled',
+    // },
+    // {
+    //   config: createConfig({
+    //     input: 'petstore.yaml',
+    //     output: 'plugins/@pinia/colada/complexConfiguration',
+    //     plugins: [
+    //       {
+    //         exportFromIndex: true,
+    //         groupByTag: true,
+    //         mutationOptions: {
+    //           case: 'camelCase',
+    //           meta: (operation) => ({
+    //             method: operation.method,
+    //             operationId: operation.id,
+    //           }),
+    //           name: 'use{{name}}Mutation',
+    //         },
+    //         name: '@pinia/colada',
+    //         operationTypes: {
+    //           addPet: 'query',
+    //           getPetById: 'both',
+    //           updatePet: 'mutation',
+    //         },
+    //         queryOptions: {
+    //           case: 'camelCase',
+    //           meta: (operation) => ({
+    //             operationId: operation.id,
+    //             tags: operation.tags,
+    //           }),
+    //           name: 'use{{name}}Query',
+    //         },
+    //       },
+    //     ],
+    //   }),
+    //   description:
+    //     'generates Pinia Colada plugin code with complex configuration combining all features',
+    // },
     {
       config: createConfig({
         input: 'opencode.yaml',
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
index 46cb75100..31fb72aae 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
index 08e86376a..ad92f5ab0 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
@@ -131,23 +131,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -176,23 +159,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -207,23 +173,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -238,23 +187,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -286,23 +218,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -362,23 +277,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -492,23 +390,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -588,23 +469,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -619,23 +483,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -650,23 +497,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -681,27 +511,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
index ae4a57a50..c81ed8cc1 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
@@ -130,23 +130,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -175,23 +158,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -206,23 +172,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -237,23 +186,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -285,23 +217,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -361,23 +276,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -491,23 +389,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -587,23 +468,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -618,23 +482,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -649,23 +496,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -680,27 +510,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
index 37c6694ce..59f76727c 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
index ee0b2eb4c..6288ca47b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
index 11ae22144..6fd02980e 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
@@ -131,23 +131,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -176,23 +159,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -207,23 +173,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -238,23 +187,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -286,23 +218,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -362,23 +277,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -492,23 +390,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -588,23 +469,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -619,23 +483,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -650,23 +497,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -681,27 +511,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
index ce8a80a76..33994fc38 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
@@ -130,23 +130,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -175,23 +158,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -206,23 +172,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -237,23 +186,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -285,23 +217,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -361,23 +276,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -491,23 +389,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -587,23 +468,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -618,23 +482,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -649,23 +496,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -680,27 +510,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
index 280b3cb34..8f39dfcc9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
index cc25c7503..2a96019f9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
index c09df98a6..08649be60 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
@@ -131,23 +131,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -176,23 +159,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -207,23 +173,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -238,23 +187,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -286,23 +218,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -362,23 +277,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -492,23 +390,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -588,23 +469,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -619,23 +483,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -650,23 +497,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -681,27 +511,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
index e9165e5ec..29ea55274 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
@@ -130,23 +130,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -175,23 +158,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -206,23 +172,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -237,23 +186,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -285,23 +217,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -361,23 +276,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -491,23 +389,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -587,23 +468,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -618,23 +482,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -649,23 +496,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -680,27 +510,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
index 6a133c259..0dd46b62d 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
index 2bd144cb8..7bc15a9c7 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
index 21ac5bffb..b9c9a0b5b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
@@ -131,23 +131,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -176,23 +159,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -207,23 +173,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -238,23 +187,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -286,23 +218,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -362,23 +277,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -492,23 +390,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -588,23 +469,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -619,23 +483,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -650,23 +497,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -681,27 +511,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
index 8e40dc8ab..bfbc45213 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
@@ -130,23 +130,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -175,23 +158,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -206,23 +172,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -237,23 +186,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -285,23 +217,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -361,23 +276,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -491,23 +389,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -587,23 +468,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -618,23 +482,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -649,23 +496,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -680,27 +510,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
index 9d6defd97..3338e867f 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
index 10bf4c0de..7dd129efe 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
index 6211e643e..39be957f0 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
@@ -131,23 +131,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -176,23 +159,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -207,23 +173,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -238,23 +187,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -286,23 +218,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -362,23 +277,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -492,23 +390,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -588,23 +469,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -619,23 +483,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -650,23 +497,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -681,27 +511,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
index f54dbfe7c..f70d10b7d 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
@@ -130,23 +130,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -175,23 +158,6 @@ export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Op
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -206,23 +172,6 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
-
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersQueryKey(options)
-    });
-};
-
 export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -237,23 +186,6 @@ export const callWithParametersMutation = (options?: Partial<Options<CallWithPar
     return mutationOptions;
 };
 
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
 export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
         mutationFn: async (localOptions) => {
@@ -285,23 +217,6 @@ export const callWithDefaultParametersOptions = (options: Options<CallWithDefaul
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -361,23 +276,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -491,23 +389,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -587,23 +468,6 @@ export const complexTypesOptions = (options: Options<ComplexTypesData>) => {
     });
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -618,23 +482,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -649,23 +496,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
@@ -680,27 +510,6 @@ export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionBodyQueryKey = (options: Options<PostApiVbyApiVersionBodyData>) => createQueryKey('postApiVbyApiVersionBody', options);
-
-/**
- * Body should not be unknown
- * Body should not be unknown
- */
-export const postApiVbyApiVersionBodyOptions = (options: Options<PostApiVbyApiVersionBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionBodyQueryKey(options)
-    });
-};
-
 /**
  * Body should not be unknown
  * Body should not be unknown
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
index 845362da6..efc31dc02 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/@tanstack/react-query.gen.ts
index ccb6f25bb..f5cb665c9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/@tanstack/react-query.gen.ts
@@ -71,23 +71,6 @@ export const create2Mutation = (options?: Partial<Options<Create2Data>>): UseMut
     return mutationOptions;
 };
 
-export const create3QueryKey = (options?: Options<Create3Data>) => createQueryKey('create3', options);
-
-export const create3Options = (options?: Options<Create3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await create3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: create3QueryKey(options)
-    });
-};
-
 export const create3Mutation = (options?: Partial<Options<Create3Data>>): UseMutationOptions<unknown, DefaultError, Options<Create3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<Create3Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
index 46cb75100..31fb72aae 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
index d336611d7..4efd79a1b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
index 20c26b698..cf9ea84b4 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
index 37c6694ce..59f76727c 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
index ee0b2eb4c..6288ca47b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
index 2a2698b9b..60f11e5e4 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
index 68447cd01..3027147ca 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
index 280b3cb34..8f39dfcc9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
index cc25c7503..2a96019f9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
index b01639a94..621566879 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
index 3ff1fddf8..e336d4235 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
index 6a133c259..0dd46b62d 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
index 2bd144cb8..7bc15a9c7 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
index 0bc666921..bdb52f65a 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
index 84a304837..4e482e4b1 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
index 9d6defd97..3338e867f 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
index 10bf4c0de..7dd129efe 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
index 5dbae928d..be1e7957d 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
index bbc6c17bd..352f4e074 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
index 845362da6..efc31dc02 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/@tanstack/react-query.gen.ts
index ccb6f25bb..f5cb665c9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/@tanstack/react-query.gen.ts
@@ -71,23 +71,6 @@ export const create2Mutation = (options?: Partial<Options<Create2Data>>): UseMut
     return mutationOptions;
 };
 
-export const create3QueryKey = (options?: Options<Create3Data>) => createQueryKey('create3', options);
-
-export const create3Options = (options?: Options<Create3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await create3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: create3QueryKey(options)
-    });
-};
-
 export const create3Mutation = (options?: Partial<Options<Create3Data>>): UseMutationOptions<unknown, DefaultError, Options<Create3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<Create3Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/@tanstack/react-query.gen.ts
index 01e32f801..33b3cfbf8 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/@tanstack/react-query.gen.ts
@@ -114,49 +114,6 @@ export const getFooInfiniteOptions = (options: Options<GetFooData>) => {
     });
 };
 
-export const postFooQueryKey = (options: Options<PostFooData>) => createQueryKey('postFoo', options);
-
-export const postFooOptions = (options: Options<PostFooData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postFoo({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postFooQueryKey(options)
-    });
-};
-
-export const postFooInfiniteQueryKey = (options: Options<PostFooData>): QueryKey<Options<PostFooData>> => createQueryKey('postFoo', options, true);
-
-export const postFooInfiniteOptions = (options: Options<PostFooData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<PostFooData>>, number | null | Pick<QueryKey<Options<PostFooData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostFooData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    page: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postFoo({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postFooInfiniteQueryKey(options)
-    });
-};
-
 export const postFooMutation = (options?: Partial<Options<PostFooData>>): UseMutationOptions<unknown, DefaultError, Options<PostFooData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostFooData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
index 46cb75100..31fb72aae 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
index d336611d7..4efd79a1b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
index 20c26b698..cf9ea84b4 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/@tanstack/angular-query-experimental.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
index 37c6694ce..59f76727c 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/@tanstack/angular-query-experimental.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
index ee0b2eb4c..6288ca47b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/@tanstack/react-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
index 2a2698b9b..60f11e5e4 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/@tanstack/react-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
index 68447cd01..3027147ca 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/@tanstack/react-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
index 280b3cb34..8f39dfcc9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/@tanstack/react-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
index cc25c7503..2a96019f9 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/@tanstack/solid-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
index b01639a94..621566879 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/@tanstack/solid-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
index 3ff1fddf8..e336d4235 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/@tanstack/solid-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
index 6a133c259..0dd46b62d 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/@tanstack/solid-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
index 2bd144cb8..7bc15a9c7 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/@tanstack/svelte-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
index 0bc666921..bdb52f65a 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/@tanstack/svelte-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
index 84a304837..4e482e4b1 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/@tanstack/svelte-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): MutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: MutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): M
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: MutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: MutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: MutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: MutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: MutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
index 9d6defd97..3338e867f 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/@tanstack/svelte-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
index 10bf4c0de..7dd129efe 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/@tanstack/vue-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooOptions = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostQueryKey = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostOptions = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostQueryKey(options)
-    });
-};
-
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarOptions = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostQueryKey = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostOptions = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostQueryKey(options)
-    });
-};
-
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
index 5dbae928d..be1e7957d 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/@tanstack/vue-query.gen.ts
@@ -72,23 +72,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, AxiosError<DefaultError>, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -196,23 +179,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -255,23 +221,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -286,33 +235,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -323,12 +266,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -336,7 +293,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -371,94 +328,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, AxiosError<DefaultError>, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -485,49 +354,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, AxiosError<DefaultError>, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -542,23 +368,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -573,23 +382,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -621,23 +413,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -697,23 +472,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -827,23 +585,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -906,23 +647,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, AxiosError<DefaultError>, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -988,23 +712,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1033,23 +740,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1064,23 +754,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, AxiosError<DefaultError>, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1095,23 +768,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, AxiosError<DefaultError>, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
index bbc6c17bd..352f4e074 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/@tanstack/vue-query.gen.ts
@@ -71,23 +71,6 @@ export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<Pat
     return mutationOptions;
 };
 
-export const importQueryKey = (options: Options<ImportData>) => createQueryKey('import', options);
-
-export const importOptions = (options: Options<ImportData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await import_({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: importQueryKey(options)
-    });
-};
-
 export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> => {
     const mutationOptions: UseMutationOptions<ImportResponse, DefaultError, Options<ImportData>> = {
         mutationFn: async (localOptions) => {
@@ -195,23 +178,6 @@ export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<
     return mutationOptions;
 };
 
-export const postCallWithoutParametersAndResponseQueryKey = (options?: Options<PostCallWithoutParametersAndResponseData>) => createQueryKey('postCallWithoutParametersAndResponse', options);
-
-export const postCallWithoutParametersAndResponseOptions = (options?: Options<PostCallWithoutParametersAndResponseData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithoutParametersAndResponseQueryKey(options)
-    });
-};
-
 export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostCallWithoutParametersAndResponseData>> = {
         mutationFn: async (localOptions) => {
@@ -254,23 +220,6 @@ export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): U
     return mutationOptions;
 };
 
-export const callWithDescriptionsQueryKey = (options?: Options<CallWithDescriptionsData>) => createQueryKey('callWithDescriptions', options);
-
-export const callWithDescriptionsOptions = (options?: Options<CallWithDescriptionsData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDescriptionsQueryKey(options)
-    });
-};
-
 export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDescriptionsData>> = {
         mutationFn: async (localOptions) => {
@@ -285,33 +234,27 @@ export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithD
     return mutationOptions;
 };
 
-export const deprecatedCallQueryKey = (options: Options<DeprecatedCallData>) => createQueryKey('deprecatedCall', options);
-
 /**
  * @deprecated
  */
-export const deprecatedCallOptions = (options: Options<DeprecatedCallData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+        mutationFn: async (localOptions) => {
             const { data } = await deprecatedCall({
                 ...options,
-                ...queryKey[0],
-                signal,
+                ...localOptions,
                 throwOnError: true
             });
             return data;
-        },
-        queryKey: deprecatedCallQueryKey(options)
-    });
+        }
+    };
+    return mutationOptions;
 };
 
-/**
- * @deprecated
- */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeprecatedCallData>> = {
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
         mutationFn: async (localOptions) => {
-            const { data } = await deprecatedCall({
+            const { data } = await callWithParameters({
                 ...options,
                 ...localOptions,
                 throwOnError: true
@@ -322,12 +265,26 @@ export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallD
     return mutationOptions;
 };
 
-export const callWithParametersQueryKey = (options: Options<CallWithParametersData>) => createQueryKey('callWithParameters', options);
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
+    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
+        mutationFn: async (localOptions) => {
+            const { data } = await callWithWeirdParameterNames({
+                ...options,
+                ...localOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
 
-export const callWithParametersOptions = (options: Options<CallWithParametersData>) => {
+export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
     return queryOptions({
         queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithParameters({
+            const { data } = await getCallWithOptionalParam({
                 ...options,
                 ...queryKey[0],
                 signal,
@@ -335,7 +292,7 @@ export const callWithParametersOptions = (options: Options<CallWithParametersDat
             });
             return data;
         },
-        queryKey: callWithParametersQueryKey(options)
+        queryKey: getCallWithOptionalParamQueryKey(options)
     });
 };
 
@@ -370,94 +327,6 @@ const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'hea
     return params as unknown as typeof page;
 };
 
-export const callWithParametersInfiniteQueryKey = (options: Options<CallWithParametersData>): QueryKey<Options<CallWithParametersData>> => createQueryKey('callWithParameters', options, true);
-
-export const callWithParametersInfiniteOptions = (options: Options<CallWithParametersData>) => {
-    return infiniteQueryOptions<unknown, DefaultError, InfiniteData<unknown>, QueryKey<Options<CallWithParametersData>>, string | null | Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<CallWithParametersData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                query: {
-                    cursor: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await callWithParameters({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithParametersInfiniteQueryKey(options)
-    });
-};
-
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithParametersData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const callWithWeirdParameterNamesQueryKey = (options: Options<CallWithWeirdParameterNamesData>) => createQueryKey('callWithWeirdParameterNames', options);
-
-export const callWithWeirdParameterNamesOptions = (options: Options<CallWithWeirdParameterNamesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithWeirdParameterNamesQueryKey(options)
-    });
-};
-
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> => {
-    const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithWeirdParameterNamesData>> = {
-        mutationFn: async (localOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...localOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-    return mutationOptions;
-};
-
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
-
-export const getCallWithOptionalParamOptions = (options: Options<GetCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await getCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: getCallWithOptionalParamQueryKey(options)
-    });
-};
-
 export const getCallWithOptionalParamInfiniteQueryKey = (options: Options<GetCallWithOptionalParamData>): QueryKey<Options<GetCallWithOptionalParamData>> => createQueryKey('getCallWithOptionalParam', options, true);
 
 export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCallWithOptionalParamData>) => {
@@ -484,49 +353,6 @@ export const getCallWithOptionalParamInfiniteOptions = (options: Options<GetCall
     });
 };
 
-export const postCallWithOptionalParamQueryKey = (options: Options<PostCallWithOptionalParamData>) => createQueryKey('postCallWithOptionalParam', options);
-
-export const postCallWithOptionalParamOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamQueryKey(options)
-    });
-};
-
-export const postCallWithOptionalParamInfiniteQueryKey = (options: Options<PostCallWithOptionalParamData>): QueryKey<Options<PostCallWithOptionalParamData>> => createQueryKey('postCallWithOptionalParam', options, true);
-
-export const postCallWithOptionalParamInfiniteOptions = (options: Options<PostCallWithOptionalParamData>) => {
-    return infiniteQueryOptions<PostCallWithOptionalParamResponse, DefaultError, InfiniteData<PostCallWithOptionalParamResponse>, QueryKey<Options<PostCallWithOptionalParamData>>, number | null | Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
-    // @ts-ignore
-    {
-        queryFn: async ({ pageParam, queryKey, signal }) => {
-            // @ts-ignore
-            const page: Pick<QueryKey<Options<PostCallWithOptionalParamData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
-                body: {
-                    offset: pageParam
-                }
-            };
-            const params = createInfiniteParams(queryKey, page);
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...params,
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postCallWithOptionalParamInfiniteQueryKey(options)
-    });
-};
-
 export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> => {
     const mutationOptions: UseMutationOptions<PostCallWithOptionalParamResponse, DefaultError, Options<PostCallWithOptionalParamData>> = {
         mutationFn: async (localOptions) => {
@@ -541,23 +367,6 @@ export const postCallWithOptionalParamMutation = (options?: Partial<Options<Post
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionRequestBodyQueryKey = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => createQueryKey('postApiVbyApiVersionRequestBody', options);
-
-export const postApiVbyApiVersionRequestBodyOptions = (options?: Options<PostApiVbyApiVersionRequestBodyData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionRequestBodyQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionRequestBodyData>> = {
         mutationFn: async (localOptions) => {
@@ -572,23 +381,6 @@ export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Option
     return mutationOptions;
 };
 
-export const postApiVbyApiVersionFormDataQueryKey = (options?: Options<PostApiVbyApiVersionFormDataData>) => createQueryKey('postApiVbyApiVersionFormData', options);
-
-export const postApiVbyApiVersionFormDataOptions = (options?: Options<PostApiVbyApiVersionFormDataData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: postApiVbyApiVersionFormDataQueryKey(options)
-    });
-};
-
 export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<PostApiVbyApiVersionFormDataData>> = {
         mutationFn: async (localOptions) => {
@@ -620,23 +412,6 @@ export const callWithDefaultParametersOptions = (options?: Options<CallWithDefau
     });
 };
 
-export const callWithDefaultOptionalParametersQueryKey = (options?: Options<CallWithDefaultOptionalParametersData>) => createQueryKey('callWithDefaultOptionalParameters', options);
-
-export const callWithDefaultOptionalParametersOptions = (options?: Options<CallWithDefaultOptionalParametersData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDefaultOptionalParametersQueryKey(options)
-    });
-};
-
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithDefaultOptionalParametersData>> = {
         mutationFn: async (localOptions) => {
@@ -696,23 +471,6 @@ export const duplicateName2Options = (options?: Options<DuplicateName2Data>) =>
     });
 };
 
-export const duplicateName3QueryKey = (options?: Options<DuplicateName3Data>) => createQueryKey('duplicateName3', options);
-
-export const duplicateName3Options = (options?: Options<DuplicateName3Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: duplicateName3QueryKey(options)
-    });
-};
-
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DuplicateName3Data>> = {
         mutationFn: async (localOptions) => {
@@ -826,23 +584,6 @@ export const callWithResponseOptions = (options?: Options<CallWithResponseData>)
     });
 };
 
-export const callWithDuplicateResponsesQueryKey = (options?: Options<CallWithDuplicateResponsesData>) => createQueryKey('callWithDuplicateResponses', options);
-
-export const callWithDuplicateResponsesOptions = (options?: Options<CallWithDuplicateResponsesData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithDuplicateResponsesQueryKey(options)
-    });
-};
-
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> => {
     const mutationOptions: UseMutationOptions<CallWithDuplicateResponsesResponse, CallWithDuplicateResponsesError, Options<CallWithDuplicateResponsesData>> = {
         mutationFn: async (localOptions) => {
@@ -905,23 +646,6 @@ export const typesOptions = (options: Options<TypesData>) => {
     });
 };
 
-export const uploadFileQueryKey = (options: Options<UploadFileData>) => createQueryKey('uploadFile', options);
-
-export const uploadFileOptions = (options: Options<UploadFileData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: uploadFileQueryKey(options)
-    });
-};
-
 export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
     const mutationOptions: UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> = {
         mutationFn: async (localOptions) => {
@@ -987,23 +711,6 @@ export const multipartResponseOptions = (options?: Options<MultipartResponseData
     });
 };
 
-export const multipartRequestQueryKey = (options?: Options<MultipartRequestData>) => createQueryKey('multipartRequest', options);
-
-export const multipartRequestOptions = (options?: Options<MultipartRequestData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: multipartRequestQueryKey(options)
-    });
-};
-
 export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<MultipartRequestData>> = {
         mutationFn: async (localOptions) => {
@@ -1032,23 +739,6 @@ export const complexParamsMutation = (options?: Partial<Options<ComplexParamsDat
     return mutationOptions;
 };
 
-export const callWithResultFromHeaderQueryKey = (options?: Options<CallWithResultFromHeaderData>) => createQueryKey('callWithResultFromHeader', options);
-
-export const callWithResultFromHeaderOptions = (options?: Options<CallWithResultFromHeaderData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: callWithResultFromHeaderQueryKey(options)
-    });
-};
-
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<CallWithResultFromHeaderData>> = {
         mutationFn: async (localOptions) => {
@@ -1063,23 +753,6 @@ export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallW
     return mutationOptions;
 };
 
-export const testErrorCodeQueryKey = (options: Options<TestErrorCodeData>) => createQueryKey('testErrorCode', options);
-
-export const testErrorCodeOptions = (options: Options<TestErrorCodeData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: testErrorCodeQueryKey(options)
-    });
-};
-
 export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> => {
     const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<TestErrorCodeData>> = {
         mutationFn: async (localOptions) => {
@@ -1094,23 +767,6 @@ export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeDat
     return mutationOptions;
 };
 
-export const nonAsciiæøåÆøÅöôêÊ字符串QueryKey = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => createQueryKey('nonAsciiæøåÆøÅöôêÊ字符串', options);
-
-export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options<NonAsciiæøåÆøÅöôêÊ字符串Data>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: nonAsciiæøåÆøÅöôêÊ字符串QueryKey(options)
-    });
-};
-
 export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> => {
     const mutationOptions: UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, DefaultError, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
index 845362da6..efc31dc02 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/@tanstack/vue-query.gen.ts
@@ -57,23 +57,6 @@ export const getFooE = (options?: Options<GetFooData>) => {
     });
 };
 
-export const fooPostD = (options?: Options<FooPostData>) => createQueryKey('fooPost', options);
-
-export const fooPostE = (options?: Options<FooPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooPostD(options)
-    });
-};
-
 export const fooPostC = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
     const mutationOptions: UseMutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> = {
         mutationFn: async (localOptions) => {
@@ -119,23 +102,6 @@ export const getFooBarE = (options?: Options<GetFooBarData>) => {
     });
 };
 
-export const fooBarPostD = (options?: Options<FooBarPostData>) => createQueryKey('fooBarPost', options);
-
-export const fooBarPostE = (options?: Options<FooBarPostData>) => {
-    return queryOptions({
-        queryFn: async ({ queryKey, signal }) => {
-            const { data } = await fooBarPost({
-                ...options,
-                ...queryKey[0],
-                signal,
-                throwOnError: true
-            });
-            return data;
-        },
-        queryKey: fooBarPostD(options)
-    });
-};
-
 export const fooBarPostC = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {
     const mutationOptions: UseMutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> = {
         mutationFn: async (localOptions) => {
diff --git a/packages/openapi-ts-tests/main/test/openapi-ts.config.ts b/packages/openapi-ts-tests/main/test/openapi-ts.config.ts
index 2e11d60a8..f2b730285 100644
--- a/packages/openapi-ts-tests/main/test/openapi-ts.config.ts
+++ b/packages/openapi-ts-tests/main/test/openapi-ts.config.ts
@@ -36,9 +36,9 @@ export default defineConfig(() => {
         '3.1.x',
         // 'invalid',
         // 'openai.yaml',
-        // 'full.yaml',
+        'full.yaml',
         // 'opencode.yaml',
-        'zoom-video-sdk.json',
+        // 'zoom-video-sdk.json',
       ),
       // https://registry.scalar.com/@lubos-heyapi-dev-team/apis/demo-api-scalar-galaxy/latest?format=json
       // path: 'scalar:@lubos-heyapi-dev-team/demo-api-scalar-galaxy',
@@ -81,7 +81,7 @@ export default defineConfig(() => {
         // deprecated: false,
         operations: {
           include: [
-            'GET /event',
+            // 'GET /event',
             // '/^[A-Z]+ /v1//',
           ],
         },
@@ -94,6 +94,16 @@ export default defineConfig(() => {
         //   exclude: ['bar'],
         // },
       },
+      hooks: {
+        operations: {
+          isQuery: (op) => {
+            if (op.method === 'post' && op.path === '/search') {
+              return true;
+            }
+            return undefined;
+          },
+        },
+      },
       pagination: {
         // keywords: ['aa'],
       },
@@ -171,7 +181,7 @@ export default defineConfig(() => {
         // responseStyle: 'data',
         // transformer: '@hey-api/transformers',
         // transformer: true,
-        validator: 'valibot',
+        // validator: 'valibot',
         // validator: {
         //   request: 'zod',
         //   response: 'zod',
@@ -205,6 +215,16 @@ export default defineConfig(() => {
         // queryOptions: {
         //   name: '{{name}}QO',
         // },
+        '~hooks': {
+          operations: {
+            getKind: (op) => {
+              if (op.method === 'post' && op.path === '/search') {
+                return ['query'];
+              }
+              return undefined;
+            },
+          },
+        },
       },
       {
         // case: 'SCREAMING_SNAKE_CASE',
@@ -212,7 +232,7 @@ export default defineConfig(() => {
         definitions: 'z{{name}}Definition',
         exportFromIndex: true,
         metadata: true,
-        name: 'valibot',
+        // name: 'valibot',
         requests: {
           // case: 'SCREAMING_SNAKE_CASE',
           name: 'z{{name}}TestData',
@@ -241,7 +261,7 @@ export default defineConfig(() => {
         },
         exportFromIndex: true,
         metadata: true,
-        name: 'zod',
+        // name: 'zod',
         // requests: {
         //   // case: 'SCREAMING_SNAKE_CASE',
         //   // name: 'z{{name}}TestData',
@@ -273,6 +293,22 @@ export default defineConfig(() => {
         exportFromIndex: true,
         // name: '@angular/common',
       },
+      {
+        name: '@pinia/colada',
+        queryOptions: {
+          name: '{{name}}Query',
+        },
+        '~hooks': {
+          operations: {
+            getKind: (op) => {
+              if (op.method === 'post' && op.path === '/search') {
+                return ['query'];
+              }
+              return undefined;
+            },
+          },
+        },
+      },
     ],
     // useOptions: false,
     // watch: 3_000,
diff --git a/packages/openapi-ts/README.md b/packages/openapi-ts/README.md
index 68731bcdc..f449f9dc6 100644
--- a/packages/openapi-ts/README.md
+++ b/packages/openapi-ts/README.md
@@ -297,16 +297,17 @@ Don't see your client? [Build your own](https://heyapi.dev/openapi-ts/clients/cu
 
 These plugins help reduce boilerplate associated with third-party dependencies. Hey API natively supports the most popular packages. Please open an issue on [GitHub](https://github.com/hey-api/openapi-ts/issues) if you'd like us to support your favorite package.
 
+- [`@angular/common`](https://heyapi.dev/openapi-ts/plugins/angular)
 - [`@hey-api/schemas`](https://heyapi.dev/openapi-ts/output/json-schema)
 - [`@hey-api/sdk`](https://heyapi.dev/openapi-ts/output/sdk)
 - [`@hey-api/transformers`](https://heyapi.dev/openapi-ts/transformers)
 - [`@hey-api/typescript`](https://heyapi.dev/openapi-ts/output/typescript)
+- [`@pinia/colada`](https://heyapi.dev/openapi-ts/plugins/pinia-colada)
 - [`@tanstack/angular-query-experimental`](https://heyapi.dev/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/react-query`](https://heyapi.dev/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/solid-query`](https://heyapi.dev/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/svelte-query`](https://heyapi.dev/openapi-ts/plugins/tanstack-query)
 - [`@tanstack/vue-query`](https://heyapi.dev/openapi-ts/plugins/tanstack-query)
-- [`@angular/common`](https://heyapi.dev/openapi-ts/plugins/angular)
 - [`fastify`](https://heyapi.dev/openapi-ts/plugins/fastify)
 - [`valibot`](https://heyapi.dev/openapi-ts/plugins/valibot)
 - [`zod`](https://heyapi.dev/openapi-ts/plugins/zod)
@@ -328,7 +329,6 @@ The following plugins are planned but not in development yet. You can help us pr
 - [MSW](https://heyapi.dev/openapi-ts/plugins/msw)
 - [Nest](https://heyapi.dev/openapi-ts/plugins/nest)
 - [Nock](https://heyapi.dev/openapi-ts/plugins/nock)
-- [Pinia Colada](https://heyapi.dev/openapi-ts/plugins/pinia-colada)
 - [Superstruct](https://heyapi.dev/openapi-ts/plugins/superstruct)
 - [Supertest](https://heyapi.dev/openapi-ts/plugins/supertest)
 - [SWR](https://heyapi.dev/openapi-ts/plugins/swr)
diff --git a/packages/openapi-ts/src/config/parser.ts b/packages/openapi-ts/src/config/parser.ts
index b03c7e7f3..66e491486 100644
--- a/packages/openapi-ts/src/config/parser.ts
+++ b/packages/openapi-ts/src/config/parser.ts
@@ -13,6 +13,7 @@ export const defaultPaginationKeywords = [
 export const getParser = (userConfig: UserConfig): Config['parser'] => {
   const parser: Config['parser'] = {
     ...userConfig.parser,
+    hooks: {},
     pagination: {
       keywords: defaultPaginationKeywords,
     },
diff --git a/packages/openapi-ts/src/generate/__tests__/class.test.ts b/packages/openapi-ts/src/generate/__tests__/class.test.ts
index 5e4c80de3..391fdfcf8 100644
--- a/packages/openapi-ts/src/generate/__tests__/class.test.ts
+++ b/packages/openapi-ts/src/generate/__tests__/class.test.ts
@@ -36,6 +36,7 @@ describe('generateLegacyClientClass', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/generate/__tests__/core.test.ts b/packages/openapi-ts/src/generate/__tests__/core.test.ts
index beac39efd..289612173 100644
--- a/packages/openapi-ts/src/generate/__tests__/core.test.ts
+++ b/packages/openapi-ts/src/generate/__tests__/core.test.ts
@@ -51,6 +51,7 @@ describe('generateLegacyCore', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -186,6 +187,7 @@ describe('generateLegacyCore', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -304,6 +306,7 @@ describe('generateLegacyCore', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/generate/legacy/__tests__/index.test.ts b/packages/openapi-ts/src/generate/legacy/__tests__/index.test.ts
index 992050ebf..8789dfa17 100644
--- a/packages/openapi-ts/src/generate/legacy/__tests__/index.test.ts
+++ b/packages/openapi-ts/src/generate/legacy/__tests__/index.test.ts
@@ -35,6 +35,7 @@ describe('generateIndexFile', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/generate/legacy/__tests__/output.test.ts b/packages/openapi-ts/src/generate/legacy/__tests__/output.test.ts
index 4760a4267..0cce0aff1 100644
--- a/packages/openapi-ts/src/generate/legacy/__tests__/output.test.ts
+++ b/packages/openapi-ts/src/generate/legacy/__tests__/output.test.ts
@@ -49,6 +49,7 @@ describe('generateLegacyOutput', () => {
         path: './dist',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/ir/context.ts b/packages/openapi-ts/src/ir/context.ts
index e2d1974a5..f93fd99a2 100644
--- a/packages/openapi-ts/src/ir/context.ts
+++ b/packages/openapi-ts/src/ir/context.ts
@@ -6,35 +6,12 @@ import { GeneratedFile } from '../generate/file';
 import type { PluginConfigMap } from '../plugins/config';
 import { PluginInstance } from '../plugins/shared/utils/instance';
 import type { PluginNames } from '../plugins/types';
-import type { StringCase } from '../types/case';
 import type { Config } from '../types/config';
 import type { Files } from '../types/utils';
 import type { Logger } from '../utils/logger';
 import { resolveRef } from '../utils/ref';
 import type { IR } from './types';
 
-export interface ContextFile {
-  /**
-   * Define casing for identifiers in this file.
-   */
-  case?: StringCase;
-  /**
-   * Should the exports from this file be re-exported in the index barrel file?
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Unique file identifier.
-   */
-  id: string;
-  /**
-   * Relative file path to the output path.
-   *
-   * @example
-   * 'bar/foo.ts'
-   */
-  path: string;
-}
-
 export class IRContext<Spec extends Record<string, any> = any> {
   /**
    * Configuration for parsing and generating the output. This
@@ -92,7 +69,7 @@ export class IRContext<Spec extends Record<string, any> = any> {
    * Create and return a new TypeScript file. Also set the current file context
    * to the newly created file.
    */
-  public createFile(file: ContextFile): GeneratedFile {
+  public createFile(file: IR.ContextFile): GeneratedFile {
     // TODO: parser - handle attempt to create duplicate
     const outputParts = file.path.split('/');
     const outputDir = path.resolve(
@@ -127,7 +104,7 @@ export class IRContext<Spec extends Record<string, any> = any> {
   /**
    * Returns a specific file by ID from `files`.
    */
-  public file({ id }: Pick<ContextFile, 'id'>): GeneratedFile | undefined {
+  public file({ id }: Pick<IR.ContextFile, 'id'>): GeneratedFile | undefined {
     return this.files[id];
   }
 
diff --git a/packages/openapi-ts/src/ir/types.d.ts b/packages/openapi-ts/src/ir/types.d.ts
index 496bd5f7d..ed5f1dacc 100644
--- a/packages/openapi-ts/src/ir/types.d.ts
+++ b/packages/openapi-ts/src/ir/types.d.ts
@@ -3,7 +3,8 @@ import type {
   SecuritySchemeObject,
   ServerObject,
 } from '../openApi/3.1.x/types/spec';
-import type { ContextFile as CtxFile, IRContext } from './context';
+import type { StringCase } from '../types/case';
+import type { IRContext } from './context';
 import type { IRMediaType } from './mediaType';
 
 interface IRBodyObject {
@@ -24,6 +25,86 @@ interface IRComponentsObject {
   schemas?: Record<string, IRSchemaObject>;
 }
 
+interface IRContextFile {
+  /**
+   * Define casing for identifiers in this file.
+   */
+  case?: StringCase;
+  /**
+   * Should the exports from this file be re-exported in the index barrel file?
+   */
+  exportFromIndex?: boolean;
+  /**
+   * Unique file identifier.
+   */
+  id: string;
+  /**
+   * Relative file path to the output path.
+   *
+   * @example
+   * 'bar/foo.ts'
+   */
+  path: string;
+}
+
+interface IRHooks {
+  /**
+   * Hooks specifically for overriding operations behavior.
+   *
+   * Use these to classify operations, decide which outputs to generate,
+   * or apply custom behavior to individual operations.
+   */
+  operations?: {
+    /**
+     * Classify the given operation into one or more kinds.
+     *
+     * Each kind determines how we treat the operation (e.g., generating queries or mutations).
+     *
+     * **Default behavior:**
+     * - GET → 'query'
+     * - DELETE, PATCH, POST, PUT → 'mutation'
+     *
+     * **Resolution order:**
+     * 1. If `isQuery` or `isMutation` returns `true` or `false`, that overrides `getKind`.
+     * 2. If `isQuery` or `isMutation` returns `undefined`, the result of `getKind` is used.
+     *
+     * @param operation - The operation object to classify.
+     * @returns An array containing one or more of 'query' or 'mutation'.
+     */
+    getKind?: (
+      operation: IROperationObject,
+    ) => ReadonlyArray<'mutation' | 'query'>;
+    /**
+     * Check if the given operation should be treated as a mutation.
+     *
+     * This affects which outputs are generated for the operation.
+     *
+     * **Default behavior:** DELETE, PATCH, POST, and PUT operations are treated as mutations.
+     *
+     * **Resolution order:** If this returns `true` or `false`, it overrides `getKind`.
+     * If it returns `undefined`, `getKind` is used instead.
+     *
+     * @param operation - The operation object to check.
+     * @returns true if the operation is a mutation, false otherwise, or undefined to fallback to `getKind`.
+     */
+    isMutation?: (operation: IROperationObject) => boolean | undefined;
+    /**
+     * Check if the given operation should be treated as a query.
+     *
+     * This affects which outputs are generated for the operation.
+     *
+     * **Default behavior:** GET operations are treated as queries.
+     *
+     * **Resolution order:** If this returns `true` or `false`, it overrides `getKind`.
+     * If it returns `undefined`, `getKind` is used instead.
+     *
+     * @param operation - The operation object to check.
+     * @returns true if the operation is a query, false otherwise, or undefined to fallback to `getKind`.
+     */
+    isQuery?: (operation: IROperationObject) => boolean | undefined;
+  };
+}
+
 interface IROperationObject {
   body?: IRBodyObject;
   deprecated?: boolean;
@@ -221,7 +302,8 @@ export namespace IR {
   export type BodyObject = IRBodyObject;
   export type ComponentsObject = IRComponentsObject;
   export type Context<Spec extends Record<string, any> = any> = IRContext<Spec>;
-  export type ContextFile = CtxFile;
+  export type ContextFile = IRContextFile;
+  export type Hooks = IRHooks;
   export type Model = IRModel;
   export type OperationObject = IROperationObject;
   export type ParameterObject = IRParameterObject;
diff --git a/packages/openapi-ts/src/plugins/@hey-api/schemas/__tests__/schemas.test.ts b/packages/openapi-ts/src/plugins/@hey-api/schemas/__tests__/schemas.test.ts
index 5dcc3ef2d..c06633299 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/schemas/__tests__/schemas.test.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/schemas/__tests__/schemas.test.ts
@@ -38,6 +38,7 @@ describe('generateLegacySchemas', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -174,6 +175,7 @@ describe('generateLegacySchemas', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/plugins/@hey-api/sdk/__tests__/plugin.test.ts b/packages/openapi-ts/src/plugins/@hey-api/sdk/__tests__/plugin.test.ts
index 0bf6fbf96..2312055f7 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/sdk/__tests__/plugin.test.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/sdk/__tests__/plugin.test.ts
@@ -40,6 +40,7 @@ describe('handlerLegacy', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -249,6 +250,7 @@ describe('methodNameBuilder', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -380,6 +382,7 @@ describe('methodNameBuilder', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -514,6 +517,7 @@ describe('methodNameBuilder', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/plugins/@hey-api/typescript/__tests__/plugin.test.ts b/packages/openapi-ts/src/plugins/@hey-api/typescript/__tests__/plugin.test.ts
index dc7eceec9..a42f8e8bf 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/typescript/__tests__/plugin.test.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/typescript/__tests__/plugin.test.ts
@@ -38,6 +38,7 @@ describe('generateLegacyTypes', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/__tests__/plugin.test.ts b/packages/openapi-ts/src/plugins/@pinia/colada/__tests__/plugin.test.ts
new file mode 100644
index 000000000..b118b0338
--- /dev/null
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/__tests__/plugin.test.ts
@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { IR } from '../../../../ir/types';
+import type { PiniaColadaPlugin } from '../types';
+
+const createMockOperation = (
+  method: IR.OperationObject['method'],
+  id = 'testOperation',
+  tags?: ReadonlyArray<string>,
+): IR.OperationObject => ({
+  id,
+  method,
+  operationId: id,
+  path: '/test',
+  responses: {},
+  tags,
+});
+
+const createMockPlugin = (
+  config: Partial<PiniaColadaPlugin['Config']['config']> = {},
+): any => ({
+  config: {
+    exportFromIndex: false,
+    groupByTag: false,
+    ...config,
+  },
+  context: {
+    file: vi.fn(),
+  },
+  createFile: vi.fn(() => ({
+    add: vi.fn(),
+    identifier: vi.fn(() => ({ name: 'testIdentifier' })),
+    import: vi.fn(),
+  })),
+  getPlugin: vi.fn(() => ({
+    config: {
+      responseStyle: 'response',
+    },
+  })),
+});
+
+// Import the functions we want to test (we'll need to extract them from the plugin file)
+// For now, let's test the logic through integration with the plugin
+describe('@pinia/colada', () => {
+  describe('groupByTag', () => {
+    it('uses single file when groupByTag is false', () => {
+      const operation = createMockOperation('get', 'testOp', ['pet', 'store']);
+      const plugin = createMockPlugin({ groupByTag: false });
+
+      const expectedFileId = plugin.name || '@pinia/colada';
+      const actualFileId = plugin.config.groupByTag
+        ? `${plugin.name || '@pinia/colada'}/${operation.tags?.[0] || 'default'}`
+        : plugin.name || '@pinia/colada';
+
+      expect(actualFileId).toBe(expectedFileId);
+    });
+
+    it('uses separate files by tag when groupByTag is true', () => {
+      const petOperation = createMockOperation('get', 'getPet', ['pet']);
+      const storeOperation = createMockOperation('get', 'getInventory', [
+        'store',
+      ]);
+      const plugin = createMockPlugin({ groupByTag: true });
+
+      const petFileId = plugin.config.groupByTag
+        ? `${plugin.name || '@pinia/colada'}/${petOperation.tags?.[0] || 'default'}`
+        : plugin.name || '@pinia/colada';
+      const storeFileId = plugin.config.groupByTag
+        ? `${plugin.name || '@pinia/colada'}/${storeOperation.tags?.[0] || 'default'}`
+        : plugin.name || '@pinia/colada';
+
+      expect(petFileId).toBe('@pinia/colada/pet');
+      expect(storeFileId).toBe('@pinia/colada/store');
+      expect(petFileId).not.toBe(storeFileId);
+    });
+
+    it('uses default tag when operation has no tags and groupByTag is true', () => {
+      const operation = createMockOperation('get', 'testOp');
+      const plugin = createMockPlugin({ groupByTag: true });
+
+      const fileId = plugin.config.groupByTag
+        ? `${plugin.name || '@pinia/colada'}/${operation.tags?.[0] || 'default'}`
+        : plugin.name || '@pinia/colada';
+
+      expect(fileId).toBe('@pinia/colada/default');
+    });
+  });
+
+  describe('config', () => {
+    it('uses default values', () => {
+      const plugin = createMockPlugin();
+      expect(plugin.config.groupByTag).toBe(false);
+      expect(plugin.config.exportFromIndex).toBe(false);
+    });
+
+    it('allows overrides', () => {
+      const plugin = createMockPlugin({
+        exportFromIndex: true,
+        groupByTag: true,
+      });
+      expect(plugin.config.groupByTag).toBe(true);
+      expect(plugin.config.exportFromIndex).toBe(true);
+    });
+  });
+});
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/config.ts b/packages/openapi-ts/src/plugins/@pinia/colada/config.ts
index 259db6167..5aa083cf9 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/config.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/config.ts
@@ -4,20 +4,44 @@ import type { PiniaColadaPlugin } from './types';
 
 export const defaultConfig: PiniaColadaPlugin['Config'] = {
   config: {
-    enablePaginationOnKey: undefined,
-    errorHandling: 'specific',
+    case: 'camelCase',
+    comments: true,
     exportFromIndex: false,
     groupByTag: false,
-    importPath: '@pinia/colada',
-    includeTypes: true,
-    prefixUse: true,
-    suffixQueryMutation: true,
-    useInfiniteQueries: false,
   },
-  dependencies: ['@hey-api/typescript'],
+  dependencies: ['@hey-api/typescript', '@hey-api/sdk'],
   handler: handler as PiniaColadaPlugin['Handler'],
   name: '@pinia/colada',
   output: '@pinia/colada',
+  resolveConfig: (plugin, context) => {
+    plugin.config.mutationOptions = context.valueToObject({
+      defaultValue: {
+        case: plugin.config.case ?? 'camelCase',
+        enabled: true,
+        name: '{{name}}Mutation',
+      },
+      mappers: {
+        boolean: (enabled) => ({ enabled }),
+        function: (name) => ({ name }),
+        string: (name) => ({ name }),
+      },
+      value: plugin.config.mutationOptions,
+    });
+
+    plugin.config.queryOptions = context.valueToObject({
+      defaultValue: {
+        case: plugin.config.case ?? 'camelCase',
+        enabled: true,
+        name: '{{name}}Query',
+      },
+      mappers: {
+        boolean: (enabled) => ({ enabled }),
+        function: (name) => ({ name }),
+        string: (name) => ({ name }),
+      },
+      value: plugin.config.queryOptions,
+    });
+  },
 };
 
 /**
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/meta.ts b/packages/openapi-ts/src/plugins/@pinia/colada/meta.ts
new file mode 100644
index 000000000..a2755448e
--- /dev/null
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/meta.ts
@@ -0,0 +1,19 @@
+import type ts from 'typescript';
+
+import type { IR } from '../../../ir/types';
+import { tsc } from '../../../tsc';
+import type { PiniaColadaPlugin } from './types';
+
+export const handleMeta = (
+  plugin: PiniaColadaPlugin['Instance'],
+  operation: IR.OperationObject,
+  configPath: 'queryOptions' | 'mutationOptions',
+): ts.Expression | undefined => {
+  const metaFn = plugin.config[configPath].meta;
+  if (!metaFn) return;
+
+  const metaObject = metaFn(operation);
+  if (!Object.keys(metaObject).length) return;
+
+  return tsc.valueToExpression({ value: metaObject });
+};
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/mutation.ts b/packages/openapi-ts/src/plugins/@pinia/colada/mutation.ts
index b8707ecbb..59646991d 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/mutation.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/mutation.ts
@@ -1,29 +1,135 @@
+import type ts from 'typescript';
+
 import type { GeneratedFile } from '../../../generate/file';
 import type { IR } from '../../../ir/types';
+import { tsc } from '../../../tsc';
+import {
+  createOperationComment,
+  isOperationOptionsRequired,
+} from '../../shared/utils/operation';
+import { handleMeta } from './meta';
+import type { PluginState } from './state';
 import type { PiniaColadaPlugin } from './types';
-import { createComposable } from './utils';
+import { useTypeData } from './utils';
 
-/**
- * Creates a mutation function for an operation
- */
-export const createMutationFunction = ({
-  context,
+export const createMutationOptions = ({
   file,
   operation,
   plugin,
+  queryFn,
+  state,
 }: {
-  context: IR.Context;
   file: GeneratedFile;
   operation: IR.OperationObject;
   plugin: PiniaColadaPlugin['Instance'];
-}) => {
-  // Allow hooks to customize or skip mutation generation
+  queryFn: string;
+  state: PluginState;
+}): void => {
   if (
-    plugin.config.onMutation &&
-    plugin.config.onMutation(operation) === false
+    !plugin.config.mutationOptions.enabled ||
+    !plugin.hooks.operation.isMutation(operation)
   ) {
     return;
   }
 
-  createComposable({ context, file, isQuery: false, operation, plugin });
+  if (!state.hasMutations) {
+    state.hasMutations = true;
+  }
+
+  state.hasUsedQueryFn = true;
+
+  const typeData = useTypeData({ file, operation, plugin });
+
+  const identifierMutationOptions = file.identifier({
+    $ref: `#/pinia-colada-mutation-options/${operation.id}`,
+    case: plugin.config.mutationOptions.case,
+    create: true,
+    nameTransformer: plugin.config.mutationOptions.name,
+    namespace: 'value',
+  });
+
+  const awaitSdkExpression = tsc.awaitExpression({
+    expression: tsc.callExpression({
+      functionName: queryFn,
+      parameters: ['options'],
+    }),
+  });
+
+  const statements: Array<ts.Statement> = [];
+
+  if (plugin.getPlugin('@hey-api/sdk')?.config.responseStyle === 'data') {
+    statements.push(
+      tsc.returnVariable({
+        expression: awaitSdkExpression,
+      }),
+    );
+  } else {
+    statements.push(
+      tsc.constVariable({
+        destructure: true,
+        expression: awaitSdkExpression,
+        name: 'data',
+      }),
+      tsc.returnVariable({
+        expression: 'data',
+      }),
+    );
+  }
+
+  const mutationOptionsObj: Array<{ key: string; value: ts.Expression }> = [
+    {
+      key: 'mutation',
+      value: tsc.arrowFunction({
+        async: true,
+        multiLine: true,
+        parameters: [
+          {
+            name: 'options',
+            type: typeData,
+          },
+        ],
+        statements,
+      }),
+    },
+  ];
+
+  const meta = handleMeta(plugin, operation, 'mutationOptions');
+
+  if (meta) {
+    mutationOptionsObj.push({
+      key: 'meta',
+      value: meta,
+    });
+  }
+
+  const isRequiredOptionsForMutation = isOperationOptionsRequired({
+    context: plugin.context,
+    operation,
+  });
+
+  const statement = tsc.constVariable({
+    comment: plugin.config.comments
+      ? createOperationComment({ operation })
+      : undefined,
+    exportConst: true,
+    expression: tsc.arrowFunction({
+      parameters: [
+        {
+          isRequired: isRequiredOptionsForMutation,
+          name: 'options',
+          type: typeData,
+        },
+      ],
+      statements: [
+        tsc.returnStatement({
+          expression: tsc.objectExpression({
+            obj: mutationOptionsObj,
+          }),
+        }),
+      ],
+    }),
+    name: identifierMutationOptions.name || '',
+  });
+
+  file.add(statement);
 };
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/plugin.ts b/packages/openapi-ts/src/plugins/@pinia/colada/plugin.ts
index 65b3ea0d8..8e5530567 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/plugin.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/plugin.ts
@@ -1,67 +1,106 @@
-import { clientId } from '../../@hey-api/client-core/utils';
-import { createMutationFunction } from './mutation';
-import { createQueryFunction } from './query';
+import type { GeneratedFile } from '../../../generate/file';
+import { tsc } from '../../../tsc';
+import { stringCase } from '../../../utils/stringCase';
+import { sdkId } from '../../@hey-api/sdk/constants';
+import { operationClasses } from '../../@hey-api/sdk/operation';
+import { serviceFunctionIdentifier } from '../../@hey-api/sdk/plugin-legacy';
+import { createMutationOptions } from './mutation';
+import { createQueryOptions } from './query';
+import type { PluginState } from './state';
 import type { PiniaColadaPlugin } from './types';
-import { isQuery } from './utils';
+import { getFileForOperation } from './utils';
 
 export const handler: PiniaColadaPlugin['Handler'] = ({ plugin }) => {
-  if (!plugin.config.groupByTag) {
-    plugin.createFile({
-      id: plugin.name,
-      path: plugin.output,
+  const files = new Map<string, GeneratedFile>();
+  const states = new Map<string, PluginState>();
+
+  plugin.forEach('operation', ({ operation }) => {
+    const { file, state } = getFileForOperation({
+      files,
+      operation,
+      plugin,
+      states,
     });
-  }
+    state.hasUsedQueryFn = false;
 
-  // Create files based on grouping strategy
-  const getFile = (tag: string) => {
-    if (!plugin.config.groupByTag) {
-      return (
-        plugin.context.file({ id: plugin.name }) ??
-        plugin.createFile({
-          id: plugin.name,
-          path: plugin.output,
+    const sdkPlugin = plugin.getPlugin('@hey-api/sdk')!;
+    const classes = sdkPlugin.config.asClass
+      ? operationClasses({
+          context: plugin.context,
+          operation,
+          plugin: sdkPlugin,
         })
-      );
-    }
+      : undefined;
+    const entry = classes ? classes.values().next().value : undefined;
+    const queryFn =
+      // TODO: this should use class graph to determine correct path string
+      // as it's really easy to break once we change the class casing
+      (
+        entry
+          ? [
+              entry.path[0],
+              ...entry.path.slice(1).map((className: string) =>
+                stringCase({
+                  case: 'camelCase',
+                  value: className,
+                }),
+              ),
+              entry.methodName,
+            ].filter(Boolean)
+          : [
+              serviceFunctionIdentifier({
+                config: plugin.context.config,
+                handleIllegal: true,
+                id: operation.id,
+                operation,
+              }),
+            ]
+      ).join('.');
 
-    const fileId = `${plugin.name}/${tag}`;
-    return (
-      plugin.context.file({ id: fileId }) ??
-      plugin.createFile({
-        id: fileId,
-        path: `${plugin.output}/${tag}`,
-      })
-    );
-  };
-
-  plugin.forEach('operation', ({ operation }) => {
-    const file = getFile(operation.tags?.[0] || 'default');
+    createQueryOptions({
+      file,
+      operation,
+      plugin,
+      queryFn,
+      state,
+    });
 
-    // Determine if the operation should be a query or mutation
-    if (isQuery(operation, plugin)) {
-      createQueryFunction({ context: plugin.context, file, operation, plugin });
-    } else {
-      createMutationFunction({
-        context: plugin.context,
-        file,
-        operation,
-        plugin,
-      });
-    }
-  });
+    createMutationOptions({
+      file,
+      operation,
+      plugin,
+      queryFn,
+      state,
+    });
 
-  // Add client import to all generated files
-  Object.entries(plugin.context.files).forEach(([fileId, file]) => {
-    if (fileId.startsWith(plugin.name)) {
-      // Make sure we have a client import
+    if (state.hasUsedQueryFn) {
       file.import({
-        alias: '_heyApiClient',
         module: file.relativePathToFile({
           context: plugin.context,
-          id: clientId,
+          id: sdkId,
         }),
-        name: 'client',
+        name: queryFn.split('.')[0]!,
       });
     }
   });
+
+  // re-export all split files
+  if (plugin.config.groupByTag && plugin.config.exportFromIndex) {
+    const indexFile = plugin.createFile({
+      case: plugin.config.case,
+      id: `${plugin.name}/index`,
+      path: `${plugin.output}/index`,
+    });
+
+    files.forEach((_, fileId) => {
+      if (fileId !== plugin.name) {
+        const tag = fileId.split('/').pop()!;
+        indexFile.add(
+          tsc.exportAllDeclaration({
+            module: `./${tag}`,
+          }),
+        );
+      }
+    });
+  }
 };
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/query.ts b/packages/openapi-ts/src/plugins/@pinia/colada/query.ts
index 91e7e3c1f..8ae88dcd2 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/query.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/query.ts
@@ -1,25 +1,165 @@
+import type ts from 'typescript';
+
 import type { GeneratedFile } from '../../../generate/file';
 import type { IR } from '../../../ir/types';
+import { tsc } from '../../../tsc';
+import {
+  createOperationComment,
+  isOperationOptionsRequired,
+} from '../../shared/utils/operation';
+import { handleMeta } from './meta';
+import type { PluginState } from './state';
 import type { PiniaColadaPlugin } from './types';
-import { createComposable } from './utils';
+import { useTypeData } from './utils';
 
-/**
- * Creates a query function for an operation
- */
-export const createQueryFunction = ({
-  context,
+export const createQueryOptions = ({
   file,
   operation,
   plugin,
+  queryFn,
+  state,
 }: {
-  context: IR.Context;
   file: GeneratedFile;
   operation: IR.OperationObject;
   plugin: PiniaColadaPlugin['Instance'];
-}) => {
-  if (plugin.config.onQuery && plugin.config.onQuery(operation) === false) {
+  queryFn: string;
+  state: PluginState;
+}): void => {
+  if (
+    !plugin.config.queryOptions.enabled ||
+    !plugin.hooks.operation.isQuery(operation)
+  ) {
     return;
   }
 
-  createComposable({ context, file, isQuery: true, operation, plugin });
+  const isRequiredOptions = isOperationOptionsRequired({
+    context: plugin.context,
+    operation,
+  });
+
+  if (!state.hasQueries) {
+    state.hasQueries = true;
+  }
+
+  state.hasUsedQueryFn = true;
+
+  const typeData = useTypeData({ file, operation, plugin });
+
+  const identifierQueryOptions = file.identifier({
+    $ref: `#/pinia-colada-query-options/${operation.id}`,
+    case: plugin.config.queryOptions.case,
+    create: true,
+    nameTransformer: plugin.config.queryOptions.name,
+    namespace: 'value',
+  });
+
+  const awaitSdkExpression = tsc.awaitExpression({
+    expression: tsc.callExpression({
+      functionName: queryFn,
+      parameters: [
+        tsc.objectExpression({
+          multiLine: true,
+          obj: [
+            {
+              spread: 'options',
+            },
+            {
+              key: 'signal',
+              value: tsc.identifier({
+                text: 'context.signal',
+              }),
+            },
+            {
+              key: 'throwOnError',
+              value: true,
+            },
+          ],
+        }),
+      ],
+    }),
+  });
+
+  const statements: Array<ts.Statement> = [];
+
+  if (plugin.getPlugin('@hey-api/sdk')?.config.responseStyle === 'data') {
+    statements.push(
+      tsc.returnVariable({
+        expression: awaitSdkExpression,
+      }),
+    );
+  } else {
+    statements.push(
+      tsc.constVariable({
+        destructure: true,
+        expression: awaitSdkExpression,
+        name: 'data',
+      }),
+      tsc.returnVariable({
+        expression: 'data',
+      }),
+    );
+  }
+
+  const queryOptionsObj: Array<{ key: string; value: ts.Expression }> = [
+    {
+      key: 'key',
+      value: tsc.arrayLiteralExpression({
+        elements: [
+          tsc.stringLiteral({ text: operation.id || '' }),
+          tsc.identifier({ text: 'options?.path' }),
+        ],
+      }),
+    },
+    {
+      key: 'query',
+      value: tsc.arrowFunction({
+        async: true,
+        multiLine: true,
+        parameters: [
+          {
+            name: 'context',
+            type: tsc.typeReferenceNode({
+              typeName: '{ signal: AbortSignal }',
+            }),
+          },
+        ],
+        statements,
+      }),
+    },
+  ];
+
+  const meta = handleMeta(plugin, operation, 'queryOptions');
+
+  if (meta) {
+    queryOptionsObj.push({
+      key: 'meta',
+      value: meta,
+    });
+  }
+
+  const statement = tsc.constVariable({
+    comment: plugin.config.comments
+      ? createOperationComment({ operation })
+      : undefined,
+    exportConst: true,
+    expression: tsc.arrowFunction({
+      parameters: [
+        {
+          isRequired: isRequiredOptions,
+          name: 'options',
+          type: typeData,
+        },
+      ],
+      statements: [
+        tsc.returnStatement({
+          expression: tsc.objectExpression({
+            obj: queryOptionsObj,
+          }),
+        }),
+      ],
+    }),
+    name: identifierQueryOptions.name || '',
+  });
+
+  file.add(statement);
 };
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/state.ts b/packages/openapi-ts/src/plugins/@pinia/colada/state.ts
new file mode 100644
index 000000000..cbaa9c38a
--- /dev/null
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/state.ts
@@ -0,0 +1,5 @@
+export interface PluginState {
+  hasMutations: boolean;
+  hasQueries: boolean;
+  hasUsedQueryFn: boolean;
+}
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/types.d.ts b/packages/openapi-ts/src/plugins/@pinia/colada/types.d.ts
index 0282e1689..80dd9420c 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/types.d.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/types.d.ts
@@ -1,217 +1,289 @@
 import type { IR } from '../../../ir/types';
-// import type { StringCase, StringName } from '../../../types/case';
+import type { StringCase, StringName } from '../../../types/case';
 import type { DefinePlugin, Plugin } from '../../types';
 
-export type UserConfig = Plugin.Name<'@pinia/colada'> & {
-  /**
-   * Default cache time for queries in milliseconds.
-   *
-   * @default undefined
-   */
-  defaultCacheTime?: number;
-  /**
-   * Default stale time for queries in milliseconds.
-   *
-   * @default undefined
-   */
-  defaultStaleTime?: number;
-  /**
-   * Enable pagination support on this key when found in the query parameters or body.
-   *
-   * @default undefined
-   */
-  enablePaginationOnKey?: string;
-  /**
-   * How to handle error responses.
-   * 'unified' - Unified error type for all errors
-   * 'specific' - Specific error types per operation
-   *
-   * @default 'specific'
-   */
-  errorHandling?: 'unified' | 'specific';
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Group operations by tag into separate files.
-   *
-   * @default false
-   */
-  groupByTag?: boolean;
-  /**
-   * Import path for the plugin.
-   *
-   * @default '@pinia/colada'
-   */
-  importPath?: string;
-  /**
-   * Include types in the generated files.
-   *
-   * @default true
-   */
-  includeTypes?: boolean;
-  /**
-   * Custom hook to customize or skip mutation generation.
-   * Return false to skip generating a mutation for this operation.
-   *
-   * @default undefined
-   */
-  onMutation?: (operation: IR.OperationObject) => boolean | undefined;
-  /**
-   * Custom hook to customize or skip query generation.
-   * Return false to skip generating a query for this operation.
-   *
-   * @default undefined
-   */
-  onQuery?: (operation: IR.OperationObject) => boolean | undefined;
-  /**
-   * Plugin output path.
-   *
-   * @default '@pinia/colada'
-   */
-  output: string;
-  /**
-   * Whether to prefix generated function names with 'use'.
-   *
-   * @default true
-   */
-  prefixUse?: boolean;
-  /**
-   * Custom hook that determines if an operation should be a query or not.
-   * Return true to force query, false to force mutation, undefined to use default logic.
-   *
-   * @default undefined
-   */
-  resolveQuery?: (operation: IR.OperationObject) => boolean | undefined;
-  /**
-   * Custom hook to resolve query key.
-   * Default is [operation.tags?.[0] || 'default', operation.id]
-   *
-   * @default undefined
-   */
-  resolveQueryKey?: (operation: IR.OperationObject) => Array<string>;
-  /**
-   * Whether to suffix generated function names with 'Query' or 'Mutation' to indicate the type
-   * of Pinia Colada operation that is used under the hood.
-   *
-   * @default true
-   */
-  suffixQueryMutation?: boolean;
-  /**
-   * Use infinite queries.
-   *
-   * @default false
-   */
-  useInfiniteQueries?: boolean;
-};
+export type UserConfig = Plugin.Name<'@pinia/colada'> &
+  Plugin.Hooks & {
+    /**
+     * The casing convention to use for generated names.
+     *
+     * @default 'camelCase'
+     */
+    case?: StringCase;
+    /**
+     * Add comments from SDK functions to the generated Pinia Colada code?
+     *
+     * @default true
+     */
+    comments?: boolean;
+    /**
+     * Should the exports from the generated files be re-exported in the index barrel file?
+     *
+     * @default false
+     */
+    exportFromIndex?: boolean;
+    /**
+     * Group generated files by OpenAPI tags. When enabled, operations will be organized
+     * into separate files based on their tags, allowing for better code organization
+     * and tree-shaking.
+     *
+     * @default false
+     */
+    groupByTag?: boolean;
+    /**
+     * Configuration for generated mutation options helpers.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    mutationOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate mutation options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated mutation options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated mutation options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Mutation'
+           */
+          name?: StringName;
+        };
+    /**
+     * Name of the generated file.
+     *
+     * @default '@pinia/colada'
+     */
+    output?: string;
+    /**
+     * Configuration for generated query options helpers.
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
+     */
+    queryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated query options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Query'
+           */
+          name?: StringName;
+        };
+  };
 
-export type Config = Plugin.Name<'@pinia/colada'> & {
-  /**
-   * Default cache time for queries in milliseconds.
-   *
-   * @default undefined
-   */
-  defaultCacheTime: number | undefined;
-  /**
-   * Default stale time for queries in milliseconds.
-   *
-   * @default undefined
-   */
-  defaultStaleTime: number | undefined;
-  /**
-   * Enable pagination support on this key when found in the query parameters or body.
-   *
-   * @default undefined
-   */
-  enablePaginationOnKey?: string;
-  /**
-   * How to handle error responses.
-   * 'unified' - Unified error type for all errors
-   * 'specific' - Specific error types per operation
-   *
-   * @default 'specific'
-   */
-  errorHandling?: 'unified' | 'specific';
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex: boolean;
-  /**
-   * Group operations by tag into separate files.
-   *
-   * @default false
-   */
-  groupByTag?: boolean;
-  /**
-   * Import path for the plugin.
-   *
-   * @default '@pinia/colada'
-   */
-  importPath?: string;
-  /**
-   * Include types in the generated files.
-   *
-   * @default true
-   */
-  includeTypes?: boolean;
-  /**
-   * Custom hook to customize or skip mutation generation.
-   * Return false to skip generating a mutation for this operation.
-   *
-   * @default undefined
-   */
-  onMutation?: (operation: IR.OperationObject) => boolean | undefined;
-  /**
-   * Custom hook to customize or skip query generation.
-   * Return false to skip generating a query for this operation.
-   *
-   * @default undefined
-   */
-  onQuery?: (operation: IR.OperationObject) => boolean | undefined;
-  /**
-   * Plugin output path.
-   *
-   * @default '@pinia/colada'
-   */
-  output: string;
-  /**
-   * Whether to prefix generated function names with 'use'.
-   *
-   * @default true
-   */
-  prefixUse?: boolean;
-  /**
-   * Custom hook that determines if an operation should be a query or not.
-   * Return true to force query, false to force mutation, undefined to use default logic.
-   *
-   * @default undefined
-   */
-  resolveQuery?: (operation: IR.OperationObject) => boolean | undefined;
-  /**
-   * Custom hook to resolve query key.
-   * Default is [operation.tags?.[0] || 'default', operation.id]
-   *
-   * @default undefined
-   */
-  resolveQueryKey?: (operation: IR.OperationObject) => Array<string>;
-  /**
-   * Whether to suffix generated function names with 'Query' or 'Mutation' to indicate the type
-   * of Pinia Colada operation that is used under the hood.
-   *
-   * @default true
-   */
-  suffixQueryMutation?: boolean;
-  /**
-   * Use infinite queries.
-   *
-   * @default false
-   */
-  useInfiniteQueries?: boolean;
-};
+export type Config = Plugin.Name<'@pinia/colada'> &
+  Plugin.Hooks & {
+    /**
+     * The casing convention to use for generated names.
+     *
+     * @default 'camelCase'
+     */
+    case: StringCase;
+    /**
+     * Add comments from SDK functions to the generated Pinia Colada code?
+     *
+     * @default true
+     */
+    comments: boolean;
+    /**
+     * Should the exports from the generated files be re-exported in the index barrel file?
+     *
+     * @default false
+     */
+    exportFromIndex: boolean;
+    /**
+     * Group generated files by OpenAPI tags. When enabled, operations will be organized
+     * into separate files based on their tags, allowing for better code organization
+     * and tree-shaking.
+     *
+     * @default false
+     */
+    groupByTag: boolean;
+    /**
+     * Resolved configuration for generated mutation options helpers.
+     */
+    mutationOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate mutation options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated mutation options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta:
+        | ((operation: IR.OperationObject) => Record<string, unknown>)
+        | undefined;
+      /**
+       * Custom naming pattern for generated mutation options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Mutation'
+       */
+      name: StringName;
+    };
+    /**
+     * Name of the generated file.
+     *
+     * @default '@pinia/colada'
+     */
+    output: string;
+    /**
+     * Resolved configuration for generated query options helpers.
+     */
+    queryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated query options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta:
+        | ((operation: IR.OperationObject) => Record<string, unknown>)
+        | undefined;
+      /**
+       * Custom naming pattern for generated query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Query'
+       */
+      name: StringName;
+    };
+  };
 
 export type PiniaColadaPlugin = DefinePlugin<UserConfig, Config>;
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/utils.ts b/packages/openapi-ts/src/plugins/@pinia/colada/utils.ts
index 258bfad54..127d14c9b 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/utils.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/utils.ts
@@ -1,430 +1,87 @@
-import type { TypeNode } from 'typescript';
-
+import { clientApi } from '../../../generate/client';
 import type { GeneratedFile } from '../../../generate/file';
 import type { IR } from '../../../ir/types';
-import type { Property } from '../../../tsc';
-import { tsc } from '../../../tsc';
-import { escapeComment } from '../../../utils/escape';
-import { stringCase } from '../../../utils/stringCase';
-import { irParametersToIrSchema } from '../../@hey-api/typescript/operation';
-import { schemaToType } from '../../@hey-api/typescript/plugin';
+import { sdkId } from '../../@hey-api/sdk/constants';
+import { operationOptionsType } from '../../@hey-api/sdk/operation';
+import type { PluginState } from './state';
 import type { PiniaColadaPlugin } from './types';
 
-const importIdentifierData = () => ({
-  name: '',
-});
-const importIdentifierError = () => ({
-  name: '',
-});
-const importIdentifierResponse = () => ({
-  name: '',
-});
-
-/**
- * Determines if an operation should be a query or mutation
- */
-export const isQuery = (
-  operation: IR.OperationObject,
-  plugin: PiniaColadaPlugin['Instance'],
-): boolean => {
-  // 1. Check for hook override
-  const hookResult = plugin.config.resolveQuery?.(operation);
-  if (hookResult !== undefined) {
-    return hookResult;
-  }
-
-  // 2. Use method as primary signal
-  if (['get', 'head', 'options'].includes(operation.method)) {
-    return true;
+export const getFileForOperation = ({
+  files,
+  operation,
+  plugin,
+  states,
+}: {
+  files: Map<string, GeneratedFile>;
+  operation: IR.OperationObject;
+  plugin: PiniaColadaPlugin['Instance'];
+  states: Map<string, PluginState>;
+}) => {
+  // single file
+  if (!plugin.config.groupByTag) {
+    const fileId = plugin.name;
+    if (!files.has(fileId)) {
+      const file = plugin.createFile({
+        case: plugin.config.case,
+        id: fileId,
+        path: plugin.output,
+      });
+      files.set(fileId, file);
+      states.set(fileId, {
+        hasMutations: false,
+        hasQueries: false,
+        hasUsedQueryFn: false,
+      });
+      // Import Options type from SDK
+      file.import({
+        ...clientApi.Options,
+        module: file.relativePathToFile({
+          context: plugin.context,
+          id: sdkId,
+        }),
+      });
+    }
+    return { file: files.get(fileId)!, state: states.get(fileId)! };
   }
 
-  // 3. Consider body presence as secondary signal
-  // If method is not GET/HEAD/OPTIONS but also has no body schema, likely a query
-  return !operation.body?.schema;
-};
-
-/**
- * Generates the cache configuration object for a query
- */
-export const generateCacheConfig = (
-  operation: IR.OperationObject,
-  plugin: PiniaColadaPlugin['Instance'],
-) => {
-  const obj: Array<{
-    key: string;
-    value: any;
-  }> = [];
+  // group by tag
+  const tag = operation.tags?.[0] || 'default';
+  const fileId = `${plugin.name}/${tag}`;
 
-  // Use default stale time if specified in config
-  if (plugin.config.defaultStaleTime !== undefined) {
-    obj.push({
-      key: 'staleTime',
-      value: plugin.config.defaultStaleTime,
+  if (!files.has(fileId)) {
+    const file = plugin.createFile({
+      case: plugin.config.case,
+      id: fileId,
+      path: `${plugin.output}/${tag}`,
     });
-  }
-
-  // Use default cache time if specified in config
-  if (plugin.config.defaultCacheTime !== undefined) {
-    obj.push({
-      key: 'gcTime',
-      value: plugin.config.defaultCacheTime,
+    files.set(fileId, file);
+    states.set(fileId, {
+      hasMutations: false,
+      hasQueries: false,
+      hasUsedQueryFn: false,
     });
-  }
-
-  // Add pagination config if enabled and operation has pagination parameters
-  if (
-    plugin.config.enablePaginationOnKey &&
-    hasPagination(operation, plugin.config.enablePaginationOnKey)
-  ) {
-    obj.push({
-      key: 'infinite',
-      value: true,
+    // import Options type from SDK
+    file.import({
+      ...clientApi.Options,
+      module: file.relativePathToFile({ context: plugin.context, id: sdkId }),
     });
   }
-
-  return obj;
-};
-
-/**
- * Checks if operation has pagination parameters
- */
-export const hasPagination = (
-  operation: IR.OperationObject,
-  paginationParam: string,
-): boolean =>
-  // Check if operation has pagination parameter
-  !!operation.parameters?.query?.[paginationParam] ||
-  !!operation.body?.pagination;
-
-/**
- * Generates the function name for an operation
- */
-export const generateFunctionName = (
-  operation: IR.OperationObject,
-  isQueryType: boolean,
-  prefixUse: boolean = true,
-  suffixQueryMutation: boolean = true,
-): string => {
-  const operationPascalCase = stringCase({
-    case: 'PascalCase',
-    value: operation.id,
-  });
-  const prefix = prefixUse ? 'use' : '';
-  const suffix = suffixQueryMutation
-    ? isQueryType
-      ? 'Query'
-      : 'Mutation'
-    : '';
-  return `${prefix}${operationPascalCase}${suffix}`;
+  return {
+    file: files.get(fileId)!,
+    state: states.get(fileId)!,
+  };
 };
 
-const parametersPluralizedNames = [
-  'query',
-  'path',
-  'headers',
-  'body',
-  'cookies',
-] as const;
-type ParamNames = (typeof parametersPluralizedNames)[number];
-// Define a conditional type to transform the names
-type NonPluralizedName<T extends ParamNames> = T extends 'headers'
-  ? 'header'
-  : T extends 'cookies'
-    ? 'cookie'
-    : T;
-function getNonPluralizedName<T extends ParamNames>(
-  name: T,
-): NonPluralizedName<T> {
-  return (
-    ['headers', 'cookies'].includes(name) ? name.slice(0, -1) : name
-  ) as NonPluralizedName<T>;
-}
-type DataKeyNames = Exclude<ParamNames, 'cookies'>;
-function getDataSubType(identifier: string, dataKey: DataKeyNames) {
-  return tsc.indexedAccessTypeNode({
-    indexType: tsc.literalTypeNode({
-      literal: tsc.stringLiteral({
-        text: dataKey,
-      }),
-    }),
-    objectType: tsc.typeReferenceNode({
-      typeName: identifier,
-    }),
-  });
-}
-
-function createParameterConst(
-  name: ParamNames,
-  operation?: IR.OperationObject,
-) {
-  const nonPluralizedName = getNonPluralizedName(name);
-  if (nonPluralizedName === 'body' && !operation?.body?.schema) return [];
-  if (
-    nonPluralizedName !== 'body' &&
-    !operation?.parameters?.[nonPluralizedName]
-  )
-    return [];
-  return [
-    tsc.constVariable({
-      expression: tsc.callExpression({
-        functionName: 'toRef',
-        parameters: [getParameterQualifiedName(name)],
-      }),
-      name: `${name}Ref`,
-    }),
-  ];
-}
-function getParameterQualifiedName(name: ParamNames) {
-  return tsc.propertyAccessExpression({
-    expression: 'params',
-    isOptional: true,
-    name,
-  });
-}
-/**
- * Creates a composable function for an operation
- */
-export const createComposable = ({
+export const useTypeData = ({
   file,
-  isQuery,
   operation,
   plugin,
 }: {
-  context: IR.Context;
   file: GeneratedFile;
-  isQuery: boolean;
   operation: IR.OperationObject;
   plugin: PiniaColadaPlugin['Instance'];
 }) => {
-  // Import necessary functions and types
-  file.import({
-    module: '@pinia/colada',
-    name: isQuery ? 'useQuery' : 'useMutation',
-  });
-  file.import({
-    asType: true,
-    module: '@pinia/colada',
-    name: `Use${isQuery ? 'Query' : 'Mutation'}Options`,
-  });
-  file.import({
-    module: 'vue',
-    name: 'toRef',
-  });
-
-  // Get query key from hooks or generate default
-  const queryKey = plugin.config.resolveQueryKey?.(operation) ?? [
-    operation.tags?.[0] || 'default',
-    operation.id,
-  ];
-
-  // Get identifiers for data, response and error types
-  const identifierData = importIdentifierData();
-  const identifierResponse = importIdentifierResponse();
-  const identifierError = importIdentifierError();
-
-  /**
-   * Creates a parameter for a composable function
-   */
-  function createParameter(
-    name: ParamNames,
-    operation?: IR.OperationObject,
-  ): Array<Property> {
-    const nonPluralizedName = getNonPluralizedName(name);
-    if (nonPluralizedName === 'body' && !operation?.body?.schema) return [];
-    if (
-      nonPluralizedName !== 'body' &&
-      !operation?.parameters?.[nonPluralizedName]
-    )
-      return [];
-    let type: TypeNode = tsc.keywordTypeNode({ keyword: 'unknown' });
-    if (nonPluralizedName === 'cookie') {
-      type =
-        schemaToType({
-          onRef: undefined,
-          plugin: plugin as any,
-          schema: irParametersToIrSchema({
-            parameters: operation?.parameters?.cookie || {},
-          }),
-          state: {
-            usedTypeIDs: new Set(),
-          },
-        }) ?? type;
-    } else if (name !== 'cookies') {
-      type = identifierData.name
-        ? getDataSubType(identifierData.name, name)
-        : type;
-    }
-    return [
-      {
-        name,
-        type,
-      },
-    ];
-  }
-  const parameters = parametersPluralizedNames.flatMap((name) =>
-    createParameter(name, operation),
-  );
-
-  // Create the composable function
-  const node = tsc.constVariable({
-    comment: [
-      operation.deprecated && '@deprecated',
-      operation.summary && escapeComment(operation.summary),
-      operation.description && escapeComment(operation.description),
-    ].filter(Boolean),
-    exportConst: true,
-    expression: tsc.arrowFunction({
-      async: true,
-      parameters: [
-        {
-          isRequired: parameters.length > 0,
-          name: 'params',
-          type: tsc.typeInterfaceNode({
-            properties: parameters,
-            useLegacyResolution: true,
-          }),
-        },
-        // Additional Pinia Colada options
-        {
-          isRequired: false,
-          name: 'options',
-          type: tsc.typeReferenceNode({
-            typeName: isQuery
-              ? `UseQueryOptions<${identifierResponse.name || 'unknown'}, ${identifierError.name || 'unknown'}, ${identifierData.name || 'unknown'}>`
-              : `UseMutationOptions<${identifierResponse.name || 'unknown'}, ${identifierData.name || 'unknown'}, ${identifierError.name || 'unknown'}>`,
-          }),
-        },
-      ],
-      statements: [
-        // Create reactive refs for parameters
-        ...parametersPluralizedNames.flatMap((name) =>
-          createParameterConst(name, operation),
-        ),
-
-        // Create query/mutation result
-        tsc.constVariable({
-          expression: tsc.callExpression({
-            functionName: isQuery ? 'useQuery' : 'useMutation',
-            parameters: [
-              tsc.objectExpression({
-                obj: [
-                  // Query/mutation function
-                  {
-                    key: isQuery ? 'query' : 'mutation',
-                    value: tsc.callExpression({
-                      functionName: '_heyApiClient',
-                      parameters: [
-                        tsc.objectExpression({
-                          obj: [
-                            {
-                              key: 'method',
-                              value: operation.method,
-                            },
-                            {
-                              key: 'url',
-                              value: operation.path,
-                            },
-                            // Add data if it's a valid body parameter (mutations only)
-                            ...parametersPluralizedNames.flatMap((name) => {
-                              const nonPluralizedName =
-                                getNonPluralizedName(name);
-                              if (
-                                nonPluralizedName === 'body' &&
-                                !operation?.body?.schema
-                              )
-                                return [];
-                              if (
-                                nonPluralizedName !== 'body' &&
-                                !operation?.parameters?.[nonPluralizedName]
-                              )
-                                return [];
-                              return [
-                                {
-                                  key:
-                                    nonPluralizedName === 'body'
-                                      ? 'data'
-                                      : name,
-                                  value: tsc.identifier({ text: `${name}Ref` }),
-                                },
-                              ];
-                            }),
-                          ].filter(Boolean),
-                        }),
-                      ],
-                    }),
-                  },
-                  // Query key (optional for mutations)
-                  {
-                    key: 'key',
-                    value: tsc.arrayLiteralExpression({
-                      elements: [
-                        ...queryKey.map((k: string) => tsc.ots.string(k)),
-                        // Add path params to query key if they exist
-                        ...parametersPluralizedNames.flatMap((name) => {
-                          const nonPluralizedName = getNonPluralizedName(name);
-                          if (
-                            nonPluralizedName === 'body' &&
-                            !operation?.body?.schema
-                          )
-                            return [];
-                          if (
-                            nonPluralizedName !== 'body' &&
-                            !operation?.parameters?.[nonPluralizedName]
-                          )
-                            return [];
-                          return [tsc.identifier({ text: `${name}Ref` })];
-                        }),
-                      ],
-                    }),
-                  },
-                  // Spread additional options
-                  {
-                    spread: 'options',
-                  },
-                ],
-              }),
-            ],
-          }),
-          name: isQuery ? 'queryResult' : 'mutationResult',
-        }),
-
-        // Return useQuery/useMutation call with reactive parameters
-        tsc.returnStatement({
-          expression: tsc.objectExpression({
-            obj: [
-              // Spread the query/mutation result
-              {
-                spread: isQuery ? 'queryResult' : 'mutationResult',
-              },
-              // Return reactive parameters
-              ...parametersPluralizedNames.flatMap((name) => {
-                const nonPluralizedName = getNonPluralizedName(name);
-                if (nonPluralizedName === 'body' && !operation?.body?.schema)
-                  return [];
-                if (
-                  nonPluralizedName !== 'body' &&
-                  !operation?.parameters?.[nonPluralizedName]
-                )
-                  return [];
-                return [
-                  {
-                    key: name,
-                    value: tsc.identifier({ text: `${name}Ref` }),
-                  },
-                ];
-              }),
-            ],
-          }),
-        }),
-      ],
-    }),
-    name: generateFunctionName(
-      operation,
-      isQuery,
-      plugin.config.prefixUse,
-      plugin.config.suffixQueryMutation,
-    ),
-  });
-
-  file.add(node);
+  const pluginSdk = plugin.getPlugin('@hey-api/sdk')!;
+  const typeData = operationOptionsType({ file, operation, plugin: pluginSdk });
+  return typeData;
 };
diff --git a/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/config.ts b/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/config.ts
index 45fdb8cb7..15f957851 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/config.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/config.ts
@@ -34,7 +34,6 @@ export const defaultConfig: TanStackAngularQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}InfiniteOptions',
       },
       mappers: {
@@ -49,7 +48,6 @@ export const defaultConfig: TanStackAngularQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Mutation',
       },
       mappers: {
@@ -79,7 +77,6 @@ export const defaultConfig: TanStackAngularQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Options',
       },
       mappers: {
diff --git a/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/types.d.ts b/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/types.d.ts
index 0d92db4a8..b55b6c673 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/types.d.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/types.d.ts
@@ -2,461 +2,301 @@ import type { IR } from '../../../ir/types';
 import type { StringCase, StringName } from '../../../types/case';
 import type { DefinePlugin, Plugin } from '../../types';
 
-export type UserConfig = Plugin.Name<'@tanstack/angular-query-experimental'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case?: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments?: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Configuration for generated infinite query key helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query key helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated infinite query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteQueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in infinite query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated infinite query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated infinite query options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated infinite query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteOptions'
-         * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
-         */
-        name?: StringName;
-      };
-  /**
-   * Configuration for generated mutation options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  mutationOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate mutation options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated mutation options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated mutation options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Mutation'
-         * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
-         */
-        name?: StringName;
-      };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/angular-query-experimental'
-   */
-  output?: string;
-  /**
-   * Configuration for generated query keys.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query keys.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}QueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated query options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Options'
-         * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
-         */
-        name?: StringName;
-      };
-};
-
-export type Config = Plugin.Name<'@tanstack/angular-query-experimental'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex: boolean;
-  /**
-   * Resolved configuration for generated infinite query key helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
-   */
-  infiniteQueryKeys: {
+export type UserConfig = Plugin.Name<'@tanstack/angular-query-experimental'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case?: StringCase;
     /**
-     * Whether to generate infinite query key helpers.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
-    /**
-     * Custom naming pattern for generated infinite query key names. The name variable is
-     * obtained from the SDK function name.
-     *
-     * @default '{{name}}InfiniteQueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
-     */
-    name: StringName;
+    comments?: boolean;
     /**
-     * Whether to include operation tags in infinite query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
      * @default false
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated infinite query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
-   */
-  infiniteQueryOptions: {
+    exportFromIndex?: boolean;
     /**
-     * The casing convention to use for generated names.
+     * Configuration for generated infinite query key helpers.
      *
-     * @default 'camelCase'
-     */
-    case: StringCase;
-    /**
-     * Whether to generate infinite query options helpers.
+     * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    infiniteQueryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query key helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated infinite query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteQueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in infinite query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated infinite query options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Configuration for generated infinite query options helpers.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions}
      *
-     * @default false
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    infiniteQueryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated infinite query options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated infinite query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteOptions'
+           * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
+           */
+          name?: StringName;
+        };
     /**
-     * Custom naming pattern for generated infinite query options names. The name variable is
-     * obtained from the SDK function name.
+     * Configuration for generated mutation options helpers.
      *
-     * @default '{{name}}InfiniteOptions'
-     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
+     * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    name: StringName;
-  };
-  /**
-   * Resolved configuration for generated mutation options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
-   */
-  mutationOptions: {
+    mutationOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate mutation options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated mutation options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated mutation options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Mutation'
+           * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
+           */
+          name?: StringName;
+        };
     /**
-     * The casing convention to use for generated names.
+     * Name of the generated file.
      *
-     * @default 'camelCase'
+     * @default '@tanstack/angular-query-experimental'
      */
-    case: StringCase;
+    output?: string;
     /**
-     * Whether to generate mutation options helpers.
+     * Configuration for generated query keys.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    queryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query keys.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}QueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated mutation options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Configuration for generated query options helpers.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * See {@link https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions}
      *
-     * @default false
-     */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-    /**
-     * Custom naming pattern for generated mutation options names. The name variable is
-     * obtained from the SDK function name.
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @default '{{name}}Mutation'
-     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
+     * @default true
      */
-    name: StringName;
+    queryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated query options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Options'
+           * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
+           */
+          name?: StringName;
+        };
   };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/angular-query-experimental'
-   */
-  output: string;
-  /**
-   * Resolved configuration for generated query keys.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
-   */
-  queryKeys: {
+
+export type Config = Plugin.Name<'@tanstack/angular-query-experimental'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
@@ -464,76 +304,238 @@ export type Config = Plugin.Name<'@tanstack/angular-query-experimental'> & {
      */
     case: StringCase;
     /**
-     * Whether to generate query keys.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
+    comments: boolean;
     /**
-     * Custom naming pattern for generated query key names. The name variable is
-     * obtained from the SDK function name.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
-     * @default '{{name}}QueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
+     * @default false
      */
-    name: StringName;
+    exportFromIndex: boolean;
     /**
-     * Whether to include operation tags in query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Resolved configuration for generated infinite query key helpers.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
-   */
-  queryOptions: {
+    infiniteQueryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query key helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated infinite query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteQueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in infinite query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * The casing convention to use for generated names.
+     * Resolved configuration for generated infinite query options helpers.
      *
-     * @default 'camelCase'
+     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
      */
-    case: StringCase;
+    infiniteQueryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated infinite query options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated infinite query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteOptions'
+       * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
+       */
+      name: StringName;
+    };
     /**
-     * Whether to generate query options helpers.
+     * Resolved configuration for generated mutation options helpers.
      *
-     * @default true
+     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
      */
-    enabled: boolean;
+    mutationOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate mutation options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated mutation options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated mutation options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Mutation'
+       * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
+       */
+      name: StringName;
+    };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated query options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Name of the generated file.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @default '@tanstack/angular-query-experimental'
+     */
+    output: string;
+    /**
+     * Resolved configuration for generated query keys.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    queryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query keys.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}QueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * Custom naming pattern for generated query options names. The name variable is
-     * obtained from the SDK function name.
+     * Resolved configuration for generated query options helpers.
      *
-     * @default '{{name}}Options'
      * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
      */
-    name: StringName;
+    queryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated query options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Options'
+       * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
+       */
+      name: StringName;
+    };
   };
-};
 
 export type TanStackAngularQueryPlugin = DefinePlugin<UserConfig, Config>;
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/infiniteQueryOptions.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/infiniteQueryOptions.ts
index bc98e6cce..82f45aa5f 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/infiniteQueryOptions.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/infiniteQueryOptions.ts
@@ -236,10 +236,8 @@ export const createInfiniteQueryOptions = ({
   state: PluginState;
 }) => {
   if (
-    !plugin.config.infiniteQueryOptions ||
-    !(['get', 'post'] as ReadonlyArray<typeof operation.method>).includes(
-      operation.method,
-    )
+    !plugin.config.infiniteQueryOptions.enabled ||
+    !plugin.hooks.operation.isQuery(operation)
   ) {
     return state;
   }
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/meta.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/meta.ts
index 14b51978a..f51c356ff 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/meta.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/meta.ts
@@ -4,25 +4,16 @@ import type { IR } from '../../../ir/types';
 import { tsc } from '../../../tsc';
 import type { PluginInstance } from './types';
 
-/**
- * Handle the meta configuration
- * @param plugin - The plugin instance
- * @param operation - The operation object to get the meta from
- * @param targetArray - The target array to add the meta to
- * @param configPath - The path to the meta configuration
- */
 export const handleMeta = (
   plugin: PluginInstance,
   operation: IR.OperationObject,
   configPath: 'queryOptions' | 'infiniteQueryOptions' | 'mutationOptions',
 ): ts.Expression | undefined => {
-  const metaConfig = plugin.config[configPath].meta;
+  const metaFn = plugin.config[configPath].meta;
+  if (!metaFn) return;
 
-  if (typeof metaConfig !== 'function') {
-    return undefined;
-  }
+  const metaObject = metaFn(operation);
+  if (!Object.keys(metaObject).length) return;
 
-  const customMeta = metaConfig(operation);
-
-  return tsc.valueToExpression({ value: customMeta });
+  return tsc.valueToExpression({ value: metaObject });
 };
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/mutationOptions.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/mutationOptions.ts
index 98c65805f..66344240c 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/mutationOptions.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/mutationOptions.ts
@@ -22,11 +22,7 @@ export const createMutationOptions = ({
 }) => {
   if (
     !plugin.config.mutationOptions.enabled ||
-    !(
-      ['delete', 'patch', 'post', 'put'] as ReadonlyArray<
-        typeof operation.method
-      >
-    ).includes(operation.method)
+    !plugin.hooks.operation.isMutation(operation)
   ) {
     return state;
   }
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/plugin-legacy.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/plugin-legacy.ts
index 80f48bdec..22c5b78cd 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/plugin-legacy.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/plugin-legacy.ts
@@ -735,7 +735,7 @@ export const handlerLegacy = ({
 
       // queries
       if (
-        plugin.config.queryOptions &&
+        plugin.config.queryOptions.enabled &&
         (['GET', 'POST'] as ReadonlyArray<Method>).includes(operation.method)
       ) {
         if (!hasQueries) {
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/queryOptions.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/queryOptions.ts
index 9b5861481..82d94052f 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/queryOptions.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/queryOptions.ts
@@ -29,10 +29,8 @@ export const createQueryOptions = ({
   state: PluginState;
 }) => {
   if (
-    !plugin.config.queryOptions ||
-    !(['get', 'post'] as ReadonlyArray<typeof operation.method>).includes(
-      operation.method,
-    )
+    !plugin.config.queryOptions.enabled ||
+    !plugin.hooks.operation.isQuery(operation)
   ) {
     return state;
   }
diff --git a/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts
index ea3d6ff7a..dce6b8a7e 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts
@@ -34,7 +34,6 @@ export const defaultConfig: TanStackReactQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}InfiniteOptions',
       },
       mappers: {
@@ -49,7 +48,6 @@ export const defaultConfig: TanStackReactQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Mutation',
       },
       mappers: {
@@ -79,7 +77,6 @@ export const defaultConfig: TanStackReactQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Options',
       },
       mappers: {
diff --git a/packages/openapi-ts/src/plugins/@tanstack/react-query/types.d.ts b/packages/openapi-ts/src/plugins/@tanstack/react-query/types.d.ts
index 01c290cb4..4fb01c73c 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/react-query/types.d.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/react-query/types.d.ts
@@ -2,459 +2,310 @@ import type { IR } from '../../../ir/types';
 import type { StringCase, StringName } from '../../../types/case';
 import type { DefinePlugin, Plugin } from '../../types';
 
-export type UserConfig = Plugin.Name<'@tanstack/react-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case?: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   * Duplicating comments this way is useful so you don't need to drill into
-   * the underlying SDK function to learn what it does or whether it's
-   * deprecated. You can set this option to `false` if you prefer less
-   * comment duplication.
-   *
-   * @default true
-   */
-  comments?: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index
-   * barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Configuration for generated infinite query key helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions TanStack Query: infiniteQueryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query key helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated infinite query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteQueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in infinite query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated infinite query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions TanStack Query: infiniteQueryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated infinite query options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated infinite query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteOptions'
-         * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
-         */
-        name?: StringName;
-      };
-  /**
-   * Configuration for generated mutation options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/useMutation TanStack Query: useMutation}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  mutationOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate mutation options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated mutation options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated mutation options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Mutation'
-         * @see https://tanstack.com/query/v5/docs/framework/react/reference/useMutation
-         */
-        name?: StringName;
-      };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/react-query'
-   */
-  output?: string;
-  /**
-   * Configuration for generated query keys.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/queryKey TanStack Query: queryKey}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query keys.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}QueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryKey
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions TanStack Query: queryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated query options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-
-        /**
-         * Custom naming pattern for generated query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Options'
-         * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions
-         */
-        name?: StringName;
-      };
-};
-
-export type Config = Plugin.Name<'@tanstack/react-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex: boolean;
-  /**
-   * Resolved configuration for generated infinite query key helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
-   */
-  infiniteQueryKeys: {
+export type UserConfig = Plugin.Name<'@tanstack/react-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case?: StringCase;
     /**
-     * Whether to generate infinite query key helpers.
+     * Add comments from SDK functions to the generated TanStack Query code?
+     * Duplicating comments this way is useful so you don't need to drill into
+     * the underlying SDK function to learn what it does or whether it's
+     * deprecated. You can set this option to `false` if you prefer less
+     * comment duplication.
      *
      * @default true
      */
-    enabled: boolean;
-    /**
-     * Custom naming pattern for generated infinite query key names. The name variable is obtained from the SDK function name.
-     *
-     * @default '{{name}}InfiniteQueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
-     */
-    name: StringName;
+    comments?: boolean;
     /**
-     * Whether to include operation tags in infinite query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Should the exports from the generated files be re-exported in the index
+     * barrel file?
      *
      * @default false
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated infinite query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
-   */
-  infiniteQueryOptions: {
+    exportFromIndex?: boolean;
     /**
-     * The casing convention to use for generated names.
+     * Configuration for generated infinite query key helpers.
      *
-     * @default 'camelCase'
-     */
-    case: StringCase;
-    /**
-     * Whether to generate infinite query options helpers.
+     * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions TanStack Query: infiniteQueryOptions}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    infiniteQueryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query key helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated infinite query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteQueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in infinite query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated infinite query options.
+     * Configuration for generated infinite query options helpers.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions TanStack Query: infiniteQueryOptions}
      *
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @default true
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    infiniteQueryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated infinite query options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated infinite query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteOptions'
+           * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
+           */
+          name?: StringName;
+        };
     /**
-     * Custom naming pattern for generated infinite query options names. The name variable is obtained from the SDK function name.
+     * Configuration for generated mutation options helpers.
      *
-     * @default '{{name}}InfiniteOptions'
-     * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
+     * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/useMutation TanStack Query: useMutation}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    name: StringName;
-  };
-  /**
-   * Resolved configuration for generated mutation options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/react/reference/useMutation
-   */
-  mutationOptions: {
+    mutationOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate mutation options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated mutation options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated mutation options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Mutation'
+           * @see https://tanstack.com/query/v5/docs/framework/react/reference/useMutation
+           */
+          name?: StringName;
+        };
     /**
-     * The casing convention to use for generated names.
+     * Name of the generated file.
      *
-     * @default 'camelCase'
+     * @default '@tanstack/react-query'
      */
-    case: StringCase;
+    output?: string;
     /**
-     * Whether to generate mutation options helpers.
+     * Configuration for generated query keys.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/queryKey TanStack Query: queryKey}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    queryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query keys.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}QueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryKey
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated mutation options.
+     * Configuration for generated query options helpers.
      *
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * See {@link https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions TanStack Query: queryOptions}
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
-     */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-    /**
-     * Custom naming pattern for generated mutation options names. The name variable is obtained from the SDK function name.
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @default '{{name}}Mutation'
-     * @see https://tanstack.com/query/v5/docs/framework/react/reference/useMutation
+     * @default true
      */
-    name: StringName;
+    queryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated query options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+
+          /**
+           * Custom naming pattern for generated query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Options'
+           * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions
+           */
+          name?: StringName;
+        };
   };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/react-query'
-   */
-  output: string;
-  /**
-   * Resolved configuration for generated query keys.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryKey
-   */
-  queryKeys: {
+
+export type Config = Plugin.Name<'@tanstack/react-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
@@ -462,73 +313,236 @@ export type Config = Plugin.Name<'@tanstack/react-query'> & {
      */
     case: StringCase;
     /**
-     * Whether to generate query keys.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
+    comments: boolean;
     /**
-     * Custom naming pattern for generated query key names. The name variable is obtained from the SDK function name.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
-     * @default '{{name}}QueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryKey
+     * @default false
      */
-    name: StringName;
+    exportFromIndex: boolean;
     /**
-     * Whether to include operation tags in query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Resolved configuration for generated infinite query key helpers.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions
-   */
-  queryOptions: {
+    infiniteQueryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query key helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated infinite query key names. The name variable is obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteQueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in infinite query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * The casing convention to use for generated names.
+     * Resolved configuration for generated infinite query options helpers.
      *
-     * @default 'camelCase'
+     * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
      */
-    case: StringCase;
+    infiniteQueryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated infinite query options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated infinite query options names. The name variable is obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteOptions'
+       * @see https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions
+       */
+      name: StringName;
+    };
     /**
-     * Whether to generate query options helpers.
+     * Resolved configuration for generated mutation options helpers.
      *
-     * @default true
+     * @see https://tanstack.com/query/v5/docs/framework/react/reference/useMutation
      */
-    enabled: boolean;
+    mutationOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate mutation options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated mutation options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated mutation options names. The name variable is obtained from the SDK function name.
+       *
+       * @default '{{name}}Mutation'
+       * @see https://tanstack.com/query/v5/docs/framework/react/reference/useMutation
+       */
+      name: StringName;
+    };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated query options.
+     * Name of the generated file.
      *
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * @default '@tanstack/react-query'
+     */
+    output: string;
+    /**
+     * Resolved configuration for generated query keys.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryKey
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    queryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query keys.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated query key names. The name variable is obtained from the SDK function name.
+       *
+       * @default '{{name}}QueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryKey
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * Custom naming pattern for generated query options names. The name variable is obtained from the SDK function name.
+     * Resolved configuration for generated query options helpers.
      *
-     * @default '{{name}}Options'
      * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions
      */
-    name: StringName;
+    queryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated query options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated query options names. The name variable is obtained from the SDK function name.
+       *
+       * @default '{{name}}Options'
+       * @see https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions
+       */
+      name: StringName;
+    };
   };
-};
 
 export type TanStackReactQueryPlugin = DefinePlugin<UserConfig, Config>;
diff --git a/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts
index 850c43867..7b4d7faff 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts
@@ -34,7 +34,6 @@ export const defaultConfig: TanStackSolidQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}InfiniteOptions',
       },
       mappers: {
@@ -49,7 +48,6 @@ export const defaultConfig: TanStackSolidQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Mutation',
       },
       mappers: {
@@ -79,7 +77,6 @@ export const defaultConfig: TanStackSolidQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Options',
       },
       mappers: {
diff --git a/packages/openapi-ts/src/plugins/@tanstack/solid-query/types.d.ts b/packages/openapi-ts/src/plugins/@tanstack/solid-query/types.d.ts
index c6529017e..1865edfd8 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/solid-query/types.d.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/solid-query/types.d.ts
@@ -2,460 +2,302 @@ import type { IR } from '../../../ir/types';
 import type { StringCase, StringName } from '../../../types/case';
 import type { DefinePlugin, Plugin } from '../../types';
 
-export type UserConfig = Plugin.Name<'@tanstack/solid-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case?: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments?: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Configuration for generated infinite query key helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query key helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated infinite query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteQueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in infinite query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated infinite query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated infinite query options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated infinite query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteOptions'
-         * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
-         */
-        name?: StringName;
-      };
-  /**
-   * Configuration for generated mutation options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  mutationOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate mutation options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated mutation options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated mutation options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Mutation'
-         * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
-         */
-        name?: StringName;
-      };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/solid-query'
-   */
-  output?: string;
-  /**
-   * Configuration for generated query keys.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query keys.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}QueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated query options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Options'
-         * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
-         */
-        name?: StringName;
-      };
-};
-
-export type Config = Plugin.Name<'@tanstack/solid-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex: boolean;
-  /**
-   * Resolved configuration for generated infinite query key helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
-   */
-  infiniteQueryKeys: {
+export type UserConfig = Plugin.Name<'@tanstack/solid-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case?: StringCase;
     /**
-     * Whether to generate infinite query key helpers.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
-    /**
-     * Custom naming pattern for generated infinite query key names. The name variable is
-     * obtained from the SDK function name.
-     *
-     * @default '{{name}}InfiniteQueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
-     */
-    name: StringName;
+    comments?: boolean;
     /**
-     * Whether to include operation tags in infinite query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
      * @default false
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated infinite query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
-   */
-  infiniteQueryOptions: {
+    exportFromIndex?: boolean;
     /**
-     * The casing convention to use for generated names.
+     * Configuration for generated infinite query key helpers.
      *
-     * @default 'camelCase'
-     */
-    case: StringCase;
-    /**
-     * Whether to generate infinite query options helpers.
+     * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    infiniteQueryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query key helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated infinite query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteQueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in infinite query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated infinite query options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Configuration for generated infinite query options helpers.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery}
      *
-     * @default false
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    infiniteQueryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated infinite query options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated infinite query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteOptions'
+           * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
+           */
+          name?: StringName;
+        };
     /**
-     * Custom naming pattern for generated infinite query options names. The name variable is
-     * obtained from the SDK function name.
+     * Configuration for generated mutation options helpers.
      *
-     * @default '{{name}}InfiniteOptions'
-     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
+     * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    name: StringName;
-  };
-  /**
-   * Resolved configuration for generated mutation options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
-   */
-  mutationOptions: {
+    mutationOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate mutation options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated mutation options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated mutation options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Mutation'
+           * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
+           */
+          name?: StringName;
+        };
     /**
-     * The casing convention to use for generated names.
+     * Name of the generated file.
      *
-     * @default 'camelCase'
+     * @default '@tanstack/solid-query'
      */
-    case: StringCase;
+    output?: string;
     /**
-     * Whether to generate mutation options helpers.
+     * Configuration for generated query keys.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    queryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query keys.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}QueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated mutation options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Configuration for generated query options helpers.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * See {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery}
      *
-     * @default false
-     */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-    /**
-     * Custom naming pattern for generated mutation options names. The name variable is
-     * obtained from the SDK function name.
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @default '{{name}}Mutation'
-     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
+     * @default true
      */
-    name: StringName;
+    queryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated query options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Options'
+           * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
+           */
+          name?: StringName;
+        };
   };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/solid-query'
-   */
-  output: string;
-  /**
-   * Resolved configuration for generated query keys.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
-   */
-  queryKeys: {
+
+export type Config = Plugin.Name<'@tanstack/solid-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
@@ -463,76 +305,238 @@ export type Config = Plugin.Name<'@tanstack/solid-query'> & {
      */
     case: StringCase;
     /**
-     * Whether to generate query keys.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
+    comments: boolean;
     /**
-     * Custom naming pattern for generated query key names. The name variable is
-     * obtained from the SDK function name.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
-     * @default '{{name}}QueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
+     * @default false
      */
-    name: StringName;
+    exportFromIndex: boolean;
     /**
-     * Whether to include operation tags in query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Resolved configuration for generated infinite query key helpers.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
-   */
-  queryOptions: {
+    infiniteQueryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query key helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated infinite query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteQueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in infinite query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * The casing convention to use for generated names.
+     * Resolved configuration for generated infinite query options helpers.
      *
-     * @default 'camelCase'
+     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
      */
-    case: StringCase;
+    infiniteQueryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated infinite query options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated infinite query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteOptions'
+       * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
+       */
+      name: StringName;
+    };
     /**
-     * Whether to generate query options helpers.
+     * Resolved configuration for generated mutation options helpers.
      *
-     * @default true
+     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
      */
-    enabled: boolean;
+    mutationOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate mutation options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated mutation options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated mutation options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Mutation'
+       * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
+       */
+      name: StringName;
+    };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated query options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Name of the generated file.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @default '@tanstack/solid-query'
+     */
+    output: string;
+    /**
+     * Resolved configuration for generated query keys.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    queryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query keys.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}QueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * Custom naming pattern for generated query options names. The name variable is
-     * obtained from the SDK function name.
+     * Resolved configuration for generated query options helpers.
      *
-     * @default '{{name}}Options'
      * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
      */
-    name: StringName;
+    queryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated query options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Options'
+       * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
+       */
+      name: StringName;
+    };
   };
-};
 
 export type TanStackSolidQueryPlugin = DefinePlugin<UserConfig, Config>;
diff --git a/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts
index efa0be5ef..46775feb9 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts
@@ -34,7 +34,6 @@ export const defaultConfig: TanStackSvelteQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}InfiniteOptions',
       },
       mappers: {
@@ -49,7 +48,6 @@ export const defaultConfig: TanStackSvelteQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Mutation',
       },
       mappers: {
@@ -79,7 +77,6 @@ export const defaultConfig: TanStackSvelteQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Options',
       },
       mappers: {
diff --git a/packages/openapi-ts/src/plugins/@tanstack/svelte-query/types.d.ts b/packages/openapi-ts/src/plugins/@tanstack/svelte-query/types.d.ts
index b1c8f9d04..75ccfa682 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/svelte-query/types.d.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/svelte-query/types.d.ts
@@ -2,461 +2,301 @@ import type { IR } from '../../../ir/types';
 import type { StringCase, StringName } from '../../../types/case';
 import type { DefinePlugin, Plugin } from '../../types';
 
-export type UserConfig = Plugin.Name<'@tanstack/svelte-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case?: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments?: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Configuration for generated infinite query key helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query key helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated infinite query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteQueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in infinite query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated infinite query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated infinite query options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated infinite query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteOptions'
-         * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
-         */
-        name?: StringName;
-      };
-  /**
-   * Configuration for generated mutation options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  mutationOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate mutation options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated mutation options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated mutation options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Mutation'
-         * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
-         */
-        name?: StringName;
-      };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/svelte-query'
-   */
-  output?: string;
-  /**
-   * Configuration for generated query keys.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/react/guides/query-keys}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query keys.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}QueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated query options.
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         *
-         * @default false
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Options'
-         * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
-         */
-        name?: StringName;
-      };
-};
-
-export type Config = Plugin.Name<'@tanstack/svelte-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex: boolean;
-  /**
-   * Resolved configuration for generated infinite query key helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
-   */
-  infiniteQueryKeys: {
+export type UserConfig = Plugin.Name<'@tanstack/svelte-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case?: StringCase;
     /**
-     * Whether to generate infinite query key helpers.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
-    /**
-     * Custom naming pattern for generated infinite query key names. The name variable is
-     * obtained from the SDK function name.
-     *
-     * @default '{{name}}InfiniteQueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
-     */
-    name: StringName;
+    comments?: boolean;
     /**
-     * Whether to include operation tags in infinite query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
      * @default false
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated infinite query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
-   */
-  infiniteQueryOptions: {
+    exportFromIndex?: boolean;
     /**
-     * The casing convention to use for generated names.
+     * Configuration for generated infinite query key helpers.
      *
-     * @default 'camelCase'
-     */
-    case: StringCase;
-    /**
-     * Whether to generate infinite query options helpers.
+     * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    infiniteQueryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query key helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated infinite query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteQueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in infinite query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated infinite query options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Configuration for generated infinite query options helpers.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery}
      *
-     * @default false
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    infiniteQueryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated infinite query options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated infinite query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteOptions'
+           * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
+           */
+          name?: StringName;
+        };
     /**
-     * Custom naming pattern for generated infinite query options names. The name variable is
-     * obtained from the SDK function name.
+     * Configuration for generated mutation options helpers.
      *
-     * @default '{{name}}InfiniteOptions'
-     * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
+     * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    name: StringName;
-  };
-  /**
-   * Resolved configuration for generated mutation options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
-   */
-  mutationOptions: {
+    mutationOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate mutation options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated mutation options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated mutation options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Mutation'
+           * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
+           */
+          name?: StringName;
+        };
     /**
-     * The casing convention to use for generated names.
+     * Name of the generated file.
      *
-     * @default 'camelCase'
+     * @default '@tanstack/svelte-query'
      */
-    case: StringCase;
+    output?: string;
     /**
-     * Whether to generate mutation options helpers.
+     * Configuration for generated query keys.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/react/guides/query-keys}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    queryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query keys.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}QueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated mutation options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Configuration for generated query options helpers.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * See {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery}
      *
-     * @default false
-     */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-    /**
-     * Custom naming pattern for generated mutation options names. The name variable is
-     * obtained from the SDK function name.
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @default '{{name}}Mutation'
-     * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
+     * @default true
      */
-    name: StringName;
+    queryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated query options.
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Options'
+           * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
+           */
+          name?: StringName;
+        };
   };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/svelte-query'
-   */
-  output: string;
-  /**
-   * Resolved configuration for generated query keys.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
-   */
-  queryKeys: {
+
+export type Config = Plugin.Name<'@tanstack/svelte-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
@@ -464,76 +304,238 @@ export type Config = Plugin.Name<'@tanstack/svelte-query'> & {
      */
     case: StringCase;
     /**
-     * Whether to generate query keys.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
+    comments: boolean;
     /**
-     * Custom naming pattern for generated query key names. The name variable is
-     * obtained from the SDK function name.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
-     * @default '{{name}}QueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
+     * @default false
      */
-    name: StringName;
+    exportFromIndex: boolean;
     /**
-     * Whether to include operation tags in query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Resolved configuration for generated infinite query key helpers.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
-   */
-  queryOptions: {
+    infiniteQueryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query key helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated infinite query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteQueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in infinite query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * The casing convention to use for generated names.
+     * Resolved configuration for generated infinite query options helpers.
      *
-     * @default 'camelCase'
+     * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
      */
-    case: StringCase;
+    infiniteQueryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated infinite query options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated infinite query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteOptions'
+       * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
+       */
+      name: StringName;
+    };
     /**
-     * Whether to generate query options helpers.
+     * Resolved configuration for generated mutation options helpers.
      *
-     * @default true
+     * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
      */
-    enabled: boolean;
+    mutationOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate mutation options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated mutation options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated mutation options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Mutation'
+       * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
+       */
+      name: StringName;
+    };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated query options.
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Name of the generated file.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @default '@tanstack/svelte-query'
+     */
+    output: string;
+    /**
+     * Resolved configuration for generated query keys.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    queryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query keys.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}QueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * Custom naming pattern for generated query options names. The name variable is
-     * obtained from the SDK function name.
+     * Resolved configuration for generated query options helpers.
      *
-     * @default '{{name}}Options'
      * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
      */
-    name: StringName;
+    queryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated query options.
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Options'
+       * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
+       */
+      name: StringName;
+    };
   };
-};
 
 export type TanStackSvelteQueryPlugin = DefinePlugin<UserConfig, Config>;
diff --git a/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts
index 8573d0e76..ddaad0579 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts
@@ -34,7 +34,6 @@ export const defaultConfig: TanStackVueQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}InfiniteOptions',
       },
       mappers: {
@@ -49,7 +48,6 @@ export const defaultConfig: TanStackVueQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Mutation',
       },
       mappers: {
@@ -79,7 +77,6 @@ export const defaultConfig: TanStackVueQueryPlugin['Config'] = {
       defaultValue: {
         case: plugin.config.case ?? 'camelCase',
         enabled: true,
-        meta: false,
         name: '{{name}}Options',
       },
       mappers: {
diff --git a/packages/openapi-ts/src/plugins/@tanstack/vue-query/types.d.ts b/packages/openapi-ts/src/plugins/@tanstack/vue-query/types.d.ts
index cf6e9139a..2cbb16a97 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/vue-query/types.d.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/vue-query/types.d.ts
@@ -2,456 +2,304 @@ import type { IR } from '../../../ir/types';
 import type { StringCase, StringName } from '../../../types/case';
 import type { DefinePlugin, Plugin } from '../../types';
 
-export type UserConfig = Plugin.Name<'@tanstack/vue-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case?: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments?: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Configuration for generated infinite query key helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query key helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated infinite query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteQueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in infinite query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated infinite query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  infiniteQueryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate infinite query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated infinite query options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated infinite query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}InfiniteOptions'
-         * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
-         */
-        name?: StringName;
-      };
-  /**
-   * Configuration for generated mutation options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  mutationOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate mutation options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated mutation options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated mutation options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Mutation'
-         * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
-         */
-        name?: StringName;
-      };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/vue-query'
-   */
-  output?: string;
-  /**
-   * Configuration for generated query keys.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryKeys?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query keys.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom naming pattern for generated query key names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}QueryKey'
-         * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
-         */
-        name?: StringName;
-        /**
-         * Whether to include operation tags in query keys.
-         * This will make query keys larger but provides better cache invalidation capabilities.
-         *
-         * @default false
-         */
-        tags?: boolean;
-      };
-  /**
-   * Configuration for generated query options helpers.
-   *
-   * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions}
-   *
-   * Can be:
-   * - `boolean`: Shorthand for `{ enabled: boolean }`
-   * - `string` or `function`: Shorthand for `{ name: string | function }`
-   * - `object`: Full configuration object
-   *
-   * @default true
-   */
-  queryOptions?:
-    | boolean
-    | StringName
-    | {
-        /**
-         * The casing convention to use for generated names.
-         *
-         * @default 'camelCase'
-         */
-        case?: StringCase;
-        /**
-         * Whether to generate query options helpers.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Custom function to generate metadata for the operation.
-         * Can return any valid meta object that will be included in the generated query options.
-         *
-         * @param operation - The operation object containing all available metadata
-         * @returns A meta object with any properties you want to include
-         *
-         * @example
-         * ```typescript
-         * meta: (operation) => ({
-         *   customField: operation.id,
-         *   isDeprecated: operation.deprecated,
-         *   tags: operation.tags,
-         *   customObject: {
-         *     method: operation.method,
-         *     path: operation.path
-         *   }
-         * })
-         * ```
-         */
-        meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-        /**
-         * Custom naming pattern for generated query options names. The name variable is
-         * obtained from the SDK function name.
-         *
-         * @default '{{name}}Options'
-         * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
-         */
-        name?: StringName;
-      };
-};
-
-export type Config = Plugin.Name<'@tanstack/vue-query'> & {
-  /**
-   * The casing convention to use for generated names.
-   *
-   * @default 'camelCase'
-   */
-  case: StringCase;
-  /**
-   * Add comments from SDK functions to the generated TanStack Query code?
-   *
-   * @default true
-   */
-  comments: boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex: boolean;
-  /**
-   * Resolved configuration for generated infinite query key helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
-   */
-  infiniteQueryKeys: {
+export type UserConfig = Plugin.Name<'@tanstack/vue-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case?: StringCase;
     /**
-     * Whether to generate infinite query key helpers.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
-    /**
-     * Custom naming pattern for generated infinite query key names. The name variable is
-     * obtained from the SDK function name.
-     *
-     * @default '{{name}}InfiniteQueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
-     */
-    name: StringName;
+    comments?: boolean;
     /**
-     * Whether to include operation tags in infinite query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
      * @default false
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated infinite query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
-   */
-  infiniteQueryOptions: {
+    exportFromIndex?: boolean;
     /**
-     * The casing convention to use for generated names.
+     * Configuration for generated infinite query key helpers.
      *
-     * @default 'camelCase'
-     */
-    case: StringCase;
-    /**
-     * Whether to generate infinite query options helpers.
+     * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    infiniteQueryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query key helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated infinite query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteQueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in infinite query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated infinite query options.
+     * Configuration for generated infinite query options helpers.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions}
      *
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @default true
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    infiniteQueryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate infinite query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated infinite query options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated infinite query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}InfiniteOptions'
+           * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
+           */
+          name?: StringName;
+        };
     /**
-     * Custom naming pattern for generated infinite query options names. The name variable is
-     * obtained from the SDK function name.
+     * Configuration for generated mutation options helpers.
      *
-     * @default '{{name}}InfiniteOptions'
-     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
+     * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
+     *
+     * @default true
      */
-    name: StringName;
-  };
-  /**
-   * Resolved configuration for generated mutation options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
-   */
-  mutationOptions: {
+    mutationOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate mutation options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated mutation options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated mutation options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Mutation'
+           * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+           */
+          name?: StringName;
+        };
     /**
-     * The casing convention to use for generated names.
+     * Name of the generated file.
      *
-     * @default 'camelCase'
+     * @default '@tanstack/vue-query'
      */
-    case: StringCase;
+    output?: string;
     /**
-     * Whether to generate mutation options helpers.
+     * Configuration for generated query keys.
+     *
+     * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey}
+     *
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
      * @default true
      */
-    enabled: boolean;
+    queryKeys?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query keys.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom naming pattern for generated query key names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}QueryKey'
+           * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
+           */
+          name?: StringName;
+          /**
+           * Whether to include operation tags in query keys.
+           * This will make query keys larger but provides better cache invalidation capabilities.
+           *
+           * @default false
+           */
+          tags?: boolean;
+        };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated mutation options.
+     * Configuration for generated query options helpers.
      *
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * See {@link https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions}
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
-     */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
-    /**
-     * Custom naming pattern for generated mutation options names. The name variable is
-     * obtained from the SDK function name.
+     * Can be:
+     * - `boolean`: Shorthand for `{ enabled: boolean }`
+     * - `string` or `function`: Shorthand for `{ name: string | function }`
+     * - `object`: Full configuration object
      *
-     * @default '{{name}}Mutation'
-     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+     * @default true
      */
-    name: StringName;
+    queryOptions?:
+      | boolean
+      | StringName
+      | {
+          /**
+           * The casing convention to use for generated names.
+           *
+           * @default 'camelCase'
+           */
+          case?: StringCase;
+          /**
+           * Whether to generate query options helpers.
+           *
+           * @default true
+           */
+          enabled?: boolean;
+          /**
+           * Custom function to generate metadata for the operation.
+           * Can return any valid meta object that will be included in the generated query options.
+           *
+           * @param operation - The operation object containing all available metadata
+           * @returns A meta object with any properties you want to include
+           *
+           * @example
+           * ```typescript
+           * meta: (operation) => ({
+           *   customField: operation.id,
+           *   isDeprecated: operation.deprecated,
+           *   tags: operation.tags,
+           *   customObject: {
+           *     method: operation.method,
+           *     path: operation.path
+           *   }
+           * })
+           * ```
+           *
+           * @default undefined
+           */
+          meta?: (operation: IR.OperationObject) => Record<string, unknown>;
+          /**
+           * Custom naming pattern for generated query options names. The name variable is
+           * obtained from the SDK function name.
+           *
+           * @default '{{name}}Options'
+           * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
+           */
+          name?: StringName;
+        };
   };
-  /**
-   * Name of the generated file.
-   *
-   * @default '@tanstack/vue-query'
-   */
-  output: string;
-  /**
-   * Resolved configuration for generated query keys.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
-   */
-  queryKeys: {
+
+export type Config = Plugin.Name<'@tanstack/vue-query'> &
+  Plugin.Hooks & {
     /**
      * The casing convention to use for generated names.
      *
@@ -459,75 +307,241 @@ export type Config = Plugin.Name<'@tanstack/vue-query'> & {
      */
     case: StringCase;
     /**
-     * Whether to generate query keys.
+     * Add comments from SDK functions to the generated TanStack Query code?
      *
      * @default true
      */
-    enabled: boolean;
+    comments: boolean;
     /**
-     * Custom naming pattern for generated query key names. The name variable is
-     * obtained from the SDK function name.
+     * Should the exports from the generated files be re-exported in the index barrel file?
      *
-     * @default '{{name}}QueryKey'
-     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
+     * @default false
      */
-    name: StringName;
+    exportFromIndex: boolean;
     /**
-     * Whether to include operation tags in query keys.
-     * This will make query keys larger but provides better cache invalidation capabilities.
+     * Resolved configuration for generated infinite query key helpers.
      *
-     * @default false
+     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
      */
-    tags: boolean;
-  };
-  /**
-   * Resolved configuration for generated query options helpers.
-   *
-   * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
-   */
-  queryOptions: {
+    infiniteQueryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query key helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated infinite query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteQueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in infinite query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * The casing convention to use for generated names.
+     * Resolved configuration for generated infinite query options helpers.
      *
-     * @default 'camelCase'
+     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
      */
-    case: StringCase;
+    infiniteQueryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate infinite query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated infinite query options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated infinite query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}InfiniteOptions'
+       * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
+       */
+      name: StringName;
+    };
     /**
-     * Whether to generate query options helpers.
+     * Resolved configuration for generated mutation options helpers.
      *
-     * @default true
+     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
      */
-    enabled: boolean;
+    mutationOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate mutation options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated mutation options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated mutation options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Mutation'
+       * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+       */
+      name: StringName;
+    };
     /**
-     * Custom function to generate metadata for the operation.
-     * Can return any valid meta object that will be included in the generated query options.
+     * Name of the generated file.
      *
-     * @param operation - The operation object containing all available metadata
-     * @returns A meta object with any properties you want to include
+     * @default '@tanstack/vue-query'
+     */
+    output: string;
+    /**
+     * Resolved configuration for generated query keys.
      *
-     * @example
-     * ```typescript
-     * meta: (operation) => ({
-     *   customField: operation.id,
-     *   isDeprecated: operation.deprecated,
-     *   tags: operation.tags,
-     *   customObject: {
-     *     method: operation.method,
-     *     path: operation.path
-     *   }
-     * })
-     * ```
+     * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
      */
-    meta?: false | ((operation: IR.OperationObject) => Record<string, any>);
+    queryKeys: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query keys.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom naming pattern for generated query key names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}QueryKey'
+       * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
+       */
+      name: StringName;
+      /**
+       * Whether to include operation tags in query keys.
+       * This will make query keys larger but provides better cache invalidation capabilities.
+       *
+       * @default false
+       */
+      tags: boolean;
+    };
     /**
-     * Custom naming pattern for generated query options names. The name variable is
-     * obtained from the SDK function name.
+     * Resolved configuration for generated query options helpers.
      *
-     * @default '{{name}}Options'
      * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
      */
-    name: StringName;
+    queryOptions: {
+      /**
+       * The casing convention to use for generated names.
+       *
+       * @default 'camelCase'
+       */
+      case: StringCase;
+      /**
+       * Whether to generate query options helpers.
+       *
+       * @default true
+       */
+      enabled: boolean;
+      /**
+       * Custom function to generate metadata for the operation.
+       * Can return any valid meta object that will be included in the generated query options.
+       *
+       * @param operation - The operation object containing all available metadata
+       * @returns A meta object with any properties you want to include
+       *
+       * @example
+       * ```typescript
+       * meta: (operation) => ({
+       *   customField: operation.id,
+       *   isDeprecated: operation.deprecated,
+       *   tags: operation.tags,
+       *   customObject: {
+       *     method: operation.method,
+       *     path: operation.path
+       *   }
+       * })
+       * ```
+       *
+       * @default undefined
+       */
+      meta: (operation: IR.OperationObject) => Record<string, unknown>;
+      /**
+       * Custom naming pattern for generated query options names. The name variable is
+       * obtained from the SDK function name.
+       *
+       * @default '{{name}}Options'
+       * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
+       */
+      name: StringName;
+    };
   };
-};
 
 export type TanStackVueQueryPlugin = DefinePlugin<UserConfig, Config>;
diff --git a/packages/openapi-ts/src/plugins/shared/utils/instance.ts b/packages/openapi-ts/src/plugins/shared/utils/instance.ts
index 214cfc241..f3ab4da5d 100644
--- a/packages/openapi-ts/src/plugins/shared/utils/instance.ts
+++ b/packages/openapi-ts/src/plugins/shared/utils/instance.ts
@@ -5,23 +5,39 @@ import type { PluginConfigMap } from '../../config';
 import type { Plugin } from '../../types';
 import type { WalkEvent, WalkEventType } from '../types/instance';
 
+const defaultGetKind: Required<Required<IR.Hooks>['operations']>['getKind'] = (
+  operation,
+) => {
+  switch (operation.method) {
+    case 'delete':
+    case 'patch':
+    case 'post':
+    case 'put':
+      return ['mutation'];
+    case 'get':
+      return ['query'];
+    default:
+      return [];
+  }
+};
+
 export class PluginInstance<T extends Plugin.Types = Plugin.Types> {
-  public api: T['api'];
-  public config: Omit<T['resolvedConfig'], 'name' | 'output'>;
-  public context: IR.Context;
-  public dependencies: Required<Plugin.Config<T>>['dependencies'] = [];
+  api: T['api'];
+  config: Omit<T['resolvedConfig'], 'name' | 'output'>;
+  context: IR.Context;
+  dependencies: Required<Plugin.Config<T>>['dependencies'] = [];
   private handler: Plugin.Config<T>['handler'];
-  public name: T['resolvedConfig']['name'];
-  public output: Required<T['config']>['output'];
+  name: T['resolvedConfig']['name'];
+  output: Required<T['config']>['output'];
   /**
    * The package metadata and utilities for the current context, constructed
    * from the provided dependencies. Used for managing package-related
    * information such as name, version, and dependency resolution during
    * code generation.
    */
-  public package: IR.Context['package'];
+  package: IR.Context['package'];
 
-  public constructor(
+  constructor(
     props: Pick<
       Required<Plugin.Config<T>>,
       'config' | 'dependencies' | 'handler'
@@ -42,7 +58,7 @@ export class PluginInstance<T extends Plugin.Types = Plugin.Types> {
     this.package = props.context.package;
   }
 
-  public createFile(file: IR.ContextFile) {
+  createFile(file: IR.ContextFile) {
     return this.context.createFile({
       exportFromIndex: this.config.exportFromIndex,
       ...file,
@@ -71,7 +87,7 @@ export class PluginInstance<T extends Plugin.Types = Plugin.Types> {
    *   }
    * });
    */
-  public forEach<T extends WalkEventType = WalkEventType>(
+  forEach<T extends WalkEventType = WalkEventType>(
     ...args: [
       ...events: ReadonlyArray<T>,
       callback: (event: WalkEvent<T>) => void,
@@ -216,16 +232,55 @@ export class PluginInstance<T extends Plugin.Types = Plugin.Types> {
    * @param name Plugin name as defined in the configuration.
    * @returns The plugin instance if found, undefined otherwise.
    */
-  public getPlugin<T extends keyof PluginConfigMap>(
+  getPlugin<T extends keyof PluginConfigMap>(
     name: T,
   ): T extends any ? PluginInstance<PluginConfigMap[T]> | undefined : never {
     return this.context.plugins[name] as any;
   }
 
+  hooks = {
+    operation: {
+      isMutation: (operation: IR.OperationObject): boolean =>
+        this.isOperationKind(operation, 'mutation'),
+      isQuery: (operation: IR.OperationObject): boolean =>
+        this.isOperationKind(operation, 'query'),
+    },
+  };
+
+  private isOperationKind(
+    operation: IR.OperationObject,
+    kind: 'mutation' | 'query',
+  ): boolean {
+    const methodName = kind === 'query' ? 'isQuery' : 'isMutation';
+    const isFnPlugin = this.config['~hooks']?.operations?.[methodName];
+    const isFnPluginResult = isFnPlugin?.(operation);
+    if (isFnPluginResult !== undefined) {
+      return isFnPluginResult;
+    }
+    const getKindFnPlugin = this.config['~hooks']?.operations?.getKind;
+    const getKindFnPluginResult = getKindFnPlugin?.(operation);
+    if (getKindFnPluginResult !== undefined) {
+      return getKindFnPluginResult.includes(kind);
+    }
+    const isFnParser =
+      this.context.config.parser.hooks.operations?.[methodName];
+    const isFnParserResult = isFnParser?.(operation);
+    if (isFnParserResult !== undefined) {
+      return isFnParserResult;
+    }
+    const getKindFnParser =
+      this.context.config.parser.hooks.operations?.getKind;
+    const getKindFnParserResult = getKindFnParser?.(operation);
+    if (getKindFnParserResult !== undefined) {
+      return getKindFnParserResult.includes(kind);
+    }
+    return defaultGetKind(operation).includes(kind);
+  }
+
   /**
    * Executes plugin's handler function.
    */
-  public async run() {
+  async run() {
     await this.handler({ plugin: this });
   }
 }
diff --git a/packages/openapi-ts/src/plugins/types.d.ts b/packages/openapi-ts/src/plugins/types.d.ts
index 1e2ecf882..b64aec43a 100644
--- a/packages/openapi-ts/src/plugins/types.d.ts
+++ b/packages/openapi-ts/src/plugins/types.d.ts
@@ -1,5 +1,6 @@
 import type { ValueToObject } from '../config/utils/config';
 import type { Package } from '../config/utils/package';
+import type { IR } from '../ir/types';
 import type { OpenApi as LegacyOpenApi } from '../openApi';
 import type { Client as LegacyClient } from '../types/client';
 import type { Files } from '../types/utils';
@@ -61,6 +62,13 @@ type BaseConfig = {
   exportFromIndex?: boolean;
   name: AnyPluginName;
   output?: string;
+  /**
+   * Optional hooks to override default plugin behavior.
+   *
+   * Use these to classify resources, control which outputs are generated,
+   * or provide custom behavior for specific resources.
+   */
+  '~hooks'?: IR.Hooks;
 };
 
 /**
@@ -117,6 +125,11 @@ export namespace Plugin {
     name: any;
   };
 
+  /**
+   * Generic wrapper for plugin hooks.
+   */
+  export type Hooks = Pick<BaseConfig, '~hooks'>;
+
   export interface Name<Name extends PluginNames> {
     name: Name;
   }
diff --git a/packages/openapi-ts/src/types/parser.d.ts b/packages/openapi-ts/src/types/parser.d.ts
index fcca13fb1..3c48187e3 100644
--- a/packages/openapi-ts/src/types/parser.d.ts
+++ b/packages/openapi-ts/src/types/parser.d.ts
@@ -1,3 +1,4 @@
+import type { IR } from '../ir/types';
 import type {
   OpenApiMetaObject,
   OpenApiOperationObject,
@@ -16,6 +17,13 @@ export type Parser = {
    * to plugins.
    */
   filters?: Filters;
+  /**
+   * Optional hooks to override default plugin behavior.
+   *
+   * Use these to classify resources, control which outputs are generated,
+   * or provide custom behavior for specific resources.
+   */
+  hooks?: IR.Hooks;
   /**
    * Pagination configuration.
    */
@@ -178,6 +186,13 @@ export type ResolvedParser = {
    * to plugins.
    */
   filters?: Filters;
+  /**
+   * Optional hooks to override default plugin behavior.
+   *
+   * Use these to classify resources, control which outputs are generated,
+   * or provide custom behavior for specific resources.
+   */
+  hooks: IR.Hooks;
   /**
    * Pagination configuration.
    */
diff --git a/packages/openapi-ts/src/types/utils.d.ts b/packages/openapi-ts/src/types/utils.d.ts
index 9d59bcf44..7db0b1769 100644
--- a/packages/openapi-ts/src/types/utils.d.ts
+++ b/packages/openapi-ts/src/types/utils.d.ts
@@ -1,3 +1,12 @@
 import type { GeneratedFile } from '../generate/file';
 
+/** Recursively make all non-function properties optional */
+export type DeepPartial<T> = {
+  [K in keyof T]?: T[K] extends (...args: any[]) => any
+    ? T[K]
+    : T[K] extends object
+      ? DeepPartial<T[K]>
+      : T[K];
+};
+
 export type Files = Record<string, GeneratedFile>;
diff --git a/packages/openapi-ts/src/utils/__tests__/handlebars.test.ts b/packages/openapi-ts/src/utils/__tests__/handlebars.test.ts
index 72150673c..0d8f2ddc6 100644
--- a/packages/openapi-ts/src/utils/__tests__/handlebars.test.ts
+++ b/packages/openapi-ts/src/utils/__tests__/handlebars.test.ts
@@ -34,6 +34,7 @@ describe('registerHandlebarHelpers', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
@@ -143,6 +144,7 @@ describe('registerHandlebarTemplates', () => {
         path: '',
       },
       parser: {
+        hooks: {},
         pagination: {
           keywords: [],
         },
diff --git a/packages/openapi-ts/src/utils/__tests__/parse.test.ts b/packages/openapi-ts/src/utils/__tests__/parse.test.ts
index be9d6b0f2..47ea8e92c 100644
--- a/packages/openapi-ts/src/utils/__tests__/parse.test.ts
+++ b/packages/openapi-ts/src/utils/__tests__/parse.test.ts
@@ -27,6 +27,7 @@ describe('operationNameFn', () => {
       path: '',
     },
     parser: {
+      hooks: {},
       pagination: {
         keywords: [],
       },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ea834ae13..f61deaec4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -83,8 +83,8 @@ importers:
         specifier: 8.4.0
         version: 8.4.0(jiti@2.4.2)(postcss@8.5.6)(typescript@5.8.3)(yaml@2.8.0)
       turbo:
-        specifier: 2.5.5
-        version: 2.5.5
+        specifier: 2.5.6
+        version: 2.5.6
       typescript:
         specifier: 5.8.3
         version: 5.8.3
@@ -161,7 +161,7 @@ importers:
     devDependencies:
       '@angular-devkit/build-angular':
         specifier: 19.2.0
-        version: 19.2.0(ad8313302c6bd1bca846720d94a92e78)
+        version: 19.2.0(eb50924e079ac7a2fb3e4e4a85ee02ab)
       '@angular/cli':
         specifier: 19.2.0
         version: 19.2.0(@types/node@22.10.5)(chokidar@4.0.3)
@@ -255,7 +255,7 @@ importers:
     devDependencies:
       '@angular-devkit/build-angular':
         specifier: 19.2.0
-        version: 19.2.0(ad8313302c6bd1bca846720d94a92e78)
+        version: 19.2.0(eb50924e079ac7a2fb3e4e4a85ee02ab)
       '@angular/cli':
         specifier: 19.2.0
         version: 19.2.0(@types/node@22.10.5)(chokidar@4.0.3)
@@ -605,6 +605,97 @@ importers:
         specifier: 7.1.2
         version: 7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
 
+  examples/openapi-ts-pinia-colada:
+    dependencies:
+      '@pinia/colada':
+        specifier: 0.17.2
+        version: 0.17.2(pinia@2.3.0(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3))
+      pinia:
+        specifier: 2.3.0
+        version: 2.3.0(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))
+      vue:
+        specifier: 3.5.13
+        version: 3.5.13(typescript@5.8.3)
+      vue-router:
+        specifier: 4.5.0
+        version: 4.5.0(vue@3.5.13(typescript@5.8.3))
+    devDependencies:
+      '@config/vite-base':
+        specifier: workspace:*
+        version: link:../../packages/config-vite-base
+      '@hey-api/openapi-ts':
+        specifier: workspace:*
+        version: link:../../packages/openapi-ts
+      '@rushstack/eslint-patch':
+        specifier: 1.10.5
+        version: 1.10.5
+      '@tsconfig/node20':
+        specifier: 20.1.4
+        version: 20.1.4
+      '@types/jsdom':
+        specifier: 21.1.7
+        version: 21.1.7
+      '@types/node':
+        specifier: 22.10.5
+        version: 22.10.5
+      '@vitejs/plugin-vue':
+        specifier: 5.2.1
+        version: 5.2.1(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))
+      '@vitejs/plugin-vue-jsx':
+        specifier: 4.1.1
+        version: 4.1.1(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))
+      '@vue/eslint-config-prettier':
+        specifier: 10.1.0
+        version: 10.1.0(@types/eslint@9.6.0)(eslint@9.17.0(jiti@2.4.2))(prettier@3.4.2)
+      '@vue/eslint-config-typescript':
+        specifier: 14.2.0
+        version: 14.2.0(eslint-plugin-vue@9.32.0(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3)
+      '@vue/test-utils':
+        specifier: 2.4.6
+        version: 2.4.6
+      '@vue/tsconfig':
+        specifier: 0.7.0
+        version: 0.7.0(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))
+      autoprefixer:
+        specifier: 10.4.20
+        version: 10.4.20(postcss@8.4.41)
+      eslint:
+        specifier: 9.17.0
+        version: 9.17.0(jiti@2.4.2)
+      eslint-plugin-vue:
+        specifier: 9.32.0
+        version: 9.32.0(eslint@9.17.0(jiti@2.4.2))
+      jsdom:
+        specifier: 23.0.0
+        version: 23.0.0
+      npm-run-all2:
+        specifier: 6.2.0
+        version: 6.2.0
+      postcss:
+        specifier: 8.4.41
+        version: 8.4.41
+      prettier:
+        specifier: 3.4.2
+        version: 3.4.2
+      tailwindcss:
+        specifier: 3.4.9
+        version: 3.4.9(ts-node@10.9.2(@types/node@22.10.5)(typescript@5.8.3))
+      typescript:
+        specifier: 5.8.3
+        version: 5.8.3
+      vite:
+        specifier: 7.1.2
+        version: 7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+      vite-plugin-vue-devtools:
+        specifier: 7.7.0
+        version: 7.7.0(rollup@4.46.2)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))
+      vitest:
+        specifier: 3.1.1
+        version: 3.1.1(@types/debug@4.1.12)(@types/node@22.10.5)(jiti@2.4.2)(jsdom@23.0.0)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+      vue-tsc:
+        specifier: 2.2.0
+        version: 2.2.0(typescript@5.8.3)
+
   examples/openapi-ts-sample:
     dependencies:
       '@radix-ui/react-form':
@@ -725,7 +816,7 @@ importers:
     devDependencies:
       '@angular-devkit/build-angular':
         specifier: ^19.2.0
-        version: 19.2.0(52e0e0d850a60079bb1eced59d648d90)
+        version: 19.2.0(e2f69d166062fe167432b715d99c44ce)
       '@angular/cli':
         specifier: ^19.2.0
         version: 19.2.0(@types/node@22.10.5)(chokidar@4.0.3)
@@ -1142,7 +1233,7 @@ importers:
         version: 3.3.2
       nuxt:
         specifier: 3.14.1592
-        version: 3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+        version: 3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.41.1)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))
       prettier:
         specifier: 3.4.2
         version: 3.4.2
@@ -1172,7 +1263,7 @@ importers:
     devDependencies:
       '@angular-devkit/build-angular':
         specifier: 19.2.0
-        version: 19.2.0(52e0e0d850a60079bb1eced59d648d90)
+        version: 19.2.0(e2f69d166062fe167432b715d99c44ce)
       '@angular/animations':
         specifier: 19.2.0
         version: 19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))
@@ -1212,6 +1303,9 @@ importers:
       '@hey-api/openapi-ts':
         specifier: workspace:*
         version: link:../../openapi-ts
+      '@pinia/colada':
+        specifier: 0.17.2
+        version: 0.17.2(pinia@2.3.0(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3))
       '@tanstack/angular-query-experimental':
         specifier: 5.73.3
         version: 5.73.3(@angular/common@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))(rxjs@7.8.1))(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))
@@ -1256,7 +1350,7 @@ importers:
         version: 3.3.2
       nuxt:
         specifier: 3.14.1592
-        version: 3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+        version: 3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
       prettier:
         specifier: 3.4.2
         version: 3.4.2
@@ -4028,6 +4122,12 @@ packages:
     resolution: {integrity: sha512-dfUnCxiN9H4ap84DvD2ubjw+3vUNpstxa0TneY/Paat8a3R4uQZDLSvWjmznAY/DoahqTHl9V46HF/Zs3F29pg==}
     engines: {node: '>= 10.0.0'}
 
+  '@pinia/colada@0.17.2':
+    resolution: {integrity: sha512-BOwO6dmVRFfhhSC0Pg023GOleW8QJDZIbjuFRvR/krIHyBNuwCK/75ezX9wmHAjnUFZ765wsyjF7Jx0nG1+PaA==}
+    peerDependencies:
+      pinia: ^2.2.6 || ^3.0.0
+      vue: ^3.5.17
+
   '@pkgjs/parseargs@0.11.0':
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
@@ -6589,9 +6689,6 @@ packages:
   caniuse-api@3.0.0:
     resolution: {integrity: sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==}
 
-  caniuse-lite@1.0.30001703:
-    resolution: {integrity: sha512-kRlAGTRWgPsOj7oARC9m1okJEXdL/8fekFVcxA8Hl7GH4r/sN4OJn/i6Flde373T50KS7Y37oFbMwlE8+F42kQ==}
-
   caniuse-lite@1.0.30001709:
     resolution: {integrity: sha512-NgL3vUTnDrPCZ3zTahp4fsugQ4dc7EKTSzwQDPEel6DMoMnfH2jhry9n2Zm8onbSR+f/QtKHFOA+iAQu4kbtWA==}
 
@@ -9455,16 +9552,6 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
-  nanoid@3.3.9:
-    resolution: {integrity: sha512-SppoicMGpZvbF1l3z4x7No3OlIjP7QJvC9XR7AhZr1kL133KHnKPztkKDc+Ir4aJ/1VhTySrtKhrsycmrMQfvg==}
-    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
-    hasBin: true
-
-  nanoid@5.1.3:
-    resolution: {integrity: sha512-zAbEOEr7u2CbxwoMRlz/pNSpRP0FdAU4pRaYunCdEezWohXFs+a0Xw7RfkKaezMsmSM1vttcLthJtwRnVtOfHQ==}
-    engines: {node: ^18 || >=20}
-    hasBin: true
-
   nanoid@5.1.5:
     resolution: {integrity: sha512-Ir/+ZpE9fDsNH0hQ3C68uyThDXzYcim2EqcZ8zn8Chtt1iylPT9xXJB0kPCnqzgcEGikO9RxSrh63MsmVCU7Fw==}
     engines: {node: ^18 || >=20}
@@ -11654,38 +11741,38 @@ packages:
     resolution: {integrity: sha512-+68OP1ZzSF84rTckf3FA95vJ1Zlx/uaXyiiKyPd1pA4rZNkpEvDAKmsu1xUSmbF/chCRYgZ6UZkDwC7PmzmAyA==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
-  turbo-darwin-64@2.5.5:
-    resolution: {integrity: sha512-RYnTz49u4F5tDD2SUwwtlynABNBAfbyT2uU/brJcyh5k6lDLyNfYKdKmqd3K2ls4AaiALWrFKVSBsiVwhdFNzQ==}
+  turbo-darwin-64@2.5.6:
+    resolution: {integrity: sha512-3C1xEdo4aFwMJAPvtlPqz1Sw/+cddWIOmsalHFMrsqqydcptwBfu26WW2cDm3u93bUzMbBJ8k3zNKFqxJ9ei2A==}
     cpu: [x64]
     os: [darwin]
 
-  turbo-darwin-arm64@2.5.5:
-    resolution: {integrity: sha512-Tk+ZeSNdBobZiMw9aFypQt0DlLsWSFWu1ymqsAdJLuPoAH05qCfYtRxE1pJuYHcJB5pqI+/HOxtJoQ40726Btw==}
+  turbo-darwin-arm64@2.5.6:
+    resolution: {integrity: sha512-LyiG+rD7JhMfYwLqB6k3LZQtYn8CQQUePbpA8mF/hMLPAekXdJo1g0bUPw8RZLwQXUIU/3BU7tXENvhSGz5DPA==}
     cpu: [arm64]
     os: [darwin]
 
-  turbo-linux-64@2.5.5:
-    resolution: {integrity: sha512-2/XvMGykD7VgsvWesZZYIIVXMlgBcQy+ZAryjugoTcvJv8TZzSU/B1nShcA7IAjZ0q7OsZ45uP2cOb8EgKT30w==}
+  turbo-linux-64@2.5.6:
+    resolution: {integrity: sha512-GOcUTT0xiT/pSnHL4YD6Yr3HreUhU8pUcGqcI2ksIF9b2/r/kRHwGFcsHgpG3+vtZF/kwsP0MV8FTlTObxsYIA==}
     cpu: [x64]
     os: [linux]
 
-  turbo-linux-arm64@2.5.5:
-    resolution: {integrity: sha512-DW+8CjCjybu0d7TFm9dovTTVg1VRnlkZ1rceO4zqsaLrit3DgHnN4to4uwyuf9s2V/BwS3IYcRy+HG9BL596Iw==}
+  turbo-linux-arm64@2.5.6:
+    resolution: {integrity: sha512-10Tm15bruJEA3m0V7iZcnQBpObGBcOgUcO+sY7/2vk1bweW34LMhkWi8svjV9iDF68+KJDThnYDlYE/bc7/zzQ==}
     cpu: [arm64]
     os: [linux]
 
-  turbo-windows-64@2.5.5:
-    resolution: {integrity: sha512-q5p1BOy8ChtSZfULuF1BhFMYIx6bevXu4fJ+TE/hyNfyHJIfjl90Z6jWdqAlyaFLmn99X/uw+7d6T/Y/dr5JwQ==}
+  turbo-windows-64@2.5.6:
+    resolution: {integrity: sha512-FyRsVpgaj76It0ludwZsNN40ytHN+17E4PFJyeliBEbxrGTc5BexlXVpufB7XlAaoaZVxbS6KT8RofLfDRyEPg==}
     cpu: [x64]
     os: [win32]
 
-  turbo-windows-arm64@2.5.5:
-    resolution: {integrity: sha512-AXbF1KmpHUq3PKQwddMGoKMYhHsy5t1YBQO8HZ04HLMR0rWv9adYlQ8kaeQJTko1Ay1anOBFTqaxfVOOsu7+1Q==}
+  turbo-windows-arm64@2.5.6:
+    resolution: {integrity: sha512-j/tWu8cMeQ7HPpKri6jvKtyXg9K1gRyhdK4tKrrchH8GNHscPX/F71zax58yYtLRWTiK04zNzPcUJuoS0+v/+Q==}
     cpu: [arm64]
     os: [win32]
 
-  turbo@2.5.5:
-    resolution: {integrity: sha512-eZ7wI6KjtT1eBqCnh2JPXWNUAxtoxxfi6VdBdZFvil0ychCOTxbm7YLRBi1JSt7U3c+u3CLxpoPxLdvr/Npr3A==}
+  turbo@2.5.6:
+    resolution: {integrity: sha512-gxToHmi9oTBNB05UjUsrWf0OyN5ZXtD0apOarC1KIx232Vp3WimRNy3810QzeNSgyD5rsaIDXlxlbnOzlouo+w==}
     hasBin: true
 
   type-check@0.4.0:
@@ -12774,11 +12861,11 @@ snapshots:
     transitivePeerDependencies:
       - chokidar
 
-  '@angular-devkit/build-angular@19.2.0(52e0e0d850a60079bb1eced59d648d90)':
+  '@angular-devkit/build-angular@19.2.0(e2f69d166062fe167432b715d99c44ce)':
     dependencies:
       '@ampproject/remapping': 2.3.0
       '@angular-devkit/architect': 0.1902.0(chokidar@4.0.3)
-      '@angular-devkit/build-webpack': 0.1902.0(chokidar@4.0.3)(webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.0)))(webpack@5.98.0(esbuild@0.25.0))
+      '@angular-devkit/build-webpack': 0.1902.0(chokidar@4.0.3)(webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.2)))(webpack@5.98.0(esbuild@0.25.0))
       '@angular-devkit/core': 19.2.0(chokidar@4.0.3)
       '@angular/build': 19.2.0(@angular/compiler-cli@19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(typescript@5.8.3))(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(@angular/platform-server@19.2.0(@angular/common@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))(rxjs@7.8.1))(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))(@angular/platform-browser@19.2.0(@angular/animations@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(@angular/common@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))(rxjs@7.8.1))(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0))))(@angular/ssr@19.2.15(24d23304438129326e0525b7f7a17114))(@types/node@22.10.5)(chokidar@4.0.3)(jiti@2.4.2)(karma@6.4.4)(less@4.2.2)(postcss@8.5.2)(tailwindcss@3.4.9(ts-node@10.9.2(@types/node@22.10.5)(typescript@5.8.3)))(terser@5.39.0)(typescript@5.8.3)(yaml@2.8.0)
       '@angular/compiler-cli': 19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(typescript@5.8.3)
@@ -12793,7 +12880,7 @@ snapshots:
       '@babel/runtime': 7.26.9
       '@discoveryjs/json-ext': 0.6.3
       '@ngtools/webpack': 19.2.0(@angular/compiler-cli@19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(typescript@5.8.3))(typescript@5.8.3)(webpack@5.98.0(esbuild@0.25.0))
-      '@vitejs/plugin-basic-ssl': 1.2.0(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+      '@vitejs/plugin-basic-ssl': 1.2.0(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
       ansi-colors: 4.1.3
       autoprefixer: 10.4.20(postcss@8.5.2)
       babel-loader: 9.2.1(@babel/core@7.26.9)(webpack@5.98.0(esbuild@0.25.0))
@@ -12828,9 +12915,9 @@ snapshots:
       tree-kill: 1.2.2
       tslib: 2.8.1
       typescript: 5.8.3
-      webpack: 5.98.0(esbuild@0.25.2)
-      webpack-dev-middleware: 7.4.2(webpack@5.98.0(esbuild@0.25.0))
-      webpack-dev-server: 5.2.0(webpack@5.98.0(esbuild@0.25.0))
+      webpack: 5.98.0(esbuild@0.25.0)
+      webpack-dev-middleware: 7.4.2(webpack@5.98.0(esbuild@0.25.2))
+      webpack-dev-server: 5.2.0(webpack@5.98.0(esbuild@0.25.2))
       webpack-merge: 6.0.1
       webpack-subresource-integrity: 5.1.0(webpack@5.98.0(esbuild@0.25.0))
     optionalDependencies:
@@ -12862,11 +12949,11 @@ snapshots:
       - webpack-cli
       - yaml
 
-  '@angular-devkit/build-angular@19.2.0(ad8313302c6bd1bca846720d94a92e78)':
+  '@angular-devkit/build-angular@19.2.0(eb50924e079ac7a2fb3e4e4a85ee02ab)':
     dependencies:
       '@ampproject/remapping': 2.3.0
       '@angular-devkit/architect': 0.1902.0(chokidar@4.0.3)
-      '@angular-devkit/build-webpack': 0.1902.0(chokidar@4.0.3)(webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.0)))(webpack@5.98.0(esbuild@0.25.0))
+      '@angular-devkit/build-webpack': 0.1902.0(chokidar@4.0.3)(webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.2)))(webpack@5.98.0(esbuild@0.25.0))
       '@angular-devkit/core': 19.2.0(chokidar@4.0.3)
       '@angular/build': 19.2.0(@angular/compiler-cli@19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(typescript@5.8.3))(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(@angular/platform-server@19.2.0(@angular/common@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0))(rxjs@7.8.2))(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0))(@angular/platform-browser@19.2.0(@angular/animations@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(@angular/common@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0))(rxjs@7.8.2))(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0))))(@angular/ssr@19.2.15(ceabc1ed65574f458ee716bf39609b5c))(@types/node@22.10.5)(chokidar@4.0.3)(jiti@2.4.2)(karma@6.4.4)(less@4.2.2)(postcss@8.5.2)(tailwindcss@3.4.9(ts-node@10.9.2(@types/node@22.10.5)(typescript@5.8.3)))(terser@5.39.0)(typescript@5.8.3)(yaml@2.8.0)
       '@angular/compiler-cli': 19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(typescript@5.8.3)
@@ -12881,7 +12968,7 @@ snapshots:
       '@babel/runtime': 7.26.9
       '@discoveryjs/json-ext': 0.6.3
       '@ngtools/webpack': 19.2.0(@angular/compiler-cli@19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(typescript@5.8.3))(typescript@5.8.3)(webpack@5.98.0(esbuild@0.25.0))
-      '@vitejs/plugin-basic-ssl': 1.2.0(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+      '@vitejs/plugin-basic-ssl': 1.2.0(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
       ansi-colors: 4.1.3
       autoprefixer: 10.4.20(postcss@8.5.2)
       babel-loader: 9.2.1(@babel/core@7.26.9)(webpack@5.98.0(esbuild@0.25.0))
@@ -12916,9 +13003,9 @@ snapshots:
       tree-kill: 1.2.2
       tslib: 2.8.1
       typescript: 5.8.3
-      webpack: 5.98.0(esbuild@0.25.2)
-      webpack-dev-middleware: 7.4.2(webpack@5.98.0(esbuild@0.25.0))
-      webpack-dev-server: 5.2.0(webpack@5.98.0(esbuild@0.25.0))
+      webpack: 5.98.0(esbuild@0.25.0)
+      webpack-dev-middleware: 7.4.2(webpack@5.98.0(esbuild@0.25.2))
+      webpack-dev-server: 5.2.0(webpack@5.98.0(esbuild@0.25.2))
       webpack-merge: 6.0.1
       webpack-subresource-integrity: 5.1.0(webpack@5.98.0(esbuild@0.25.0))
     optionalDependencies:
@@ -12950,12 +13037,12 @@ snapshots:
       - webpack-cli
       - yaml
 
-  '@angular-devkit/build-webpack@0.1902.0(chokidar@4.0.3)(webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.0)))(webpack@5.98.0(esbuild@0.25.0))':
+  '@angular-devkit/build-webpack@0.1902.0(chokidar@4.0.3)(webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.2)))(webpack@5.98.0(esbuild@0.25.0))':
     dependencies:
       '@angular-devkit/architect': 0.1902.0(chokidar@4.0.3)
       rxjs: 7.8.1
-      webpack: 5.98.0(esbuild@0.25.2)
-      webpack-dev-server: 5.2.0(webpack@5.98.0(esbuild@0.25.0))
+      webpack: 5.98.0(esbuild@0.25.0)
+      webpack-dev-server: 5.2.0(webpack@5.98.0(esbuild@0.25.2))
     transitivePeerDependencies:
       - chokidar
 
@@ -13365,10 +13452,10 @@ snapshots:
       '@babel/helper-compilation-targets': 7.26.5
       '@babel/helper-module-transforms': 7.26.0(@babel/core@7.26.9)
       '@babel/helpers': 7.26.10
-      '@babel/parser': 7.26.10
+      '@babel/parser': 7.28.3
       '@babel/template': 7.26.9
       '@babel/traverse': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
       convert-source-map: 2.0.0
       debug: 4.4.0(supports-color@9.4.0)
       gensync: 1.0.0-beta.2
@@ -13387,15 +13474,15 @@ snapshots:
 
   '@babel/generator@7.26.9':
     dependencies:
-      '@babel/parser': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/parser': 7.28.3
+      '@babel/types': 7.28.2
       '@jridgewell/gen-mapping': 0.3.8
       '@jridgewell/trace-mapping': 0.3.25
       jsesc: 3.1.0
 
   '@babel/helper-annotate-as-pure@7.25.9':
     dependencies:
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
 
   '@babel/helper-compilation-targets@7.26.5':
     dependencies:
@@ -13452,7 +13539,7 @@ snapshots:
   '@babel/helper-member-expression-to-functions@7.25.9':
     dependencies:
       '@babel/traverse': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
     transitivePeerDependencies:
       - supports-color
 
@@ -13483,7 +13570,7 @@ snapshots:
 
   '@babel/helper-optimise-call-expression@7.25.9':
     dependencies:
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
 
   '@babel/helper-plugin-utils@7.26.5': {}
 
@@ -13517,13 +13604,13 @@ snapshots:
   '@babel/helper-skip-transparent-expression-wrappers@7.25.9':
     dependencies:
       '@babel/traverse': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-split-export-declaration@7.24.7':
     dependencies:
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
 
   '@babel/helper-string-parser@7.25.9': {}
 
@@ -13539,7 +13626,7 @@ snapshots:
     dependencies:
       '@babel/template': 7.26.9
       '@babel/traverse': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
     transitivePeerDependencies:
       - supports-color
 
@@ -14076,7 +14163,7 @@ snapshots:
     dependencies:
       '@babel/core': 7.26.9
       '@babel/helper-plugin-utils': 7.26.5
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
       esutils: 2.0.3
 
   '@babel/runtime@7.26.10':
@@ -15317,13 +15404,13 @@ snapshots:
     dependencies:
       '@angular/compiler-cli': 19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.1)(zone.js@0.15.0)))(typescript@5.8.3)
       typescript: 5.8.3
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   '@ngtools/webpack@19.2.0(@angular/compiler-cli@19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(typescript@5.8.3))(typescript@5.8.3)(webpack@5.98.0(esbuild@0.25.0))':
     dependencies:
       '@angular/compiler-cli': 19.2.0(@angular/compiler@19.2.0(@angular/core@19.2.0(rxjs@7.8.2)(zone.js@0.15.0)))(typescript@5.8.3)
       typescript: 5.8.3
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
@@ -15400,6 +15487,26 @@ snapshots:
 
   '@nuxt/devalue@2.0.2': {}
 
+  '@nuxt/devtools-kit@1.7.0(magicast@0.3.5)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))':
+    dependencies:
+      '@nuxt/kit': 3.15.4(magicast@0.3.5)
+      '@nuxt/schema': 3.16.2
+      execa: 7.2.0
+      vite: 5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+    transitivePeerDependencies:
+      - magicast
+      - supports-color
+
+  '@nuxt/devtools-kit@1.7.0(magicast@0.3.5)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))':
+    dependencies:
+      '@nuxt/kit': 3.15.4(magicast@0.3.5)
+      '@nuxt/schema': 3.16.2
+      execa: 7.2.0
+      vite: 6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+    transitivePeerDependencies:
+      - magicast
+      - supports-color
+
   '@nuxt/devtools-kit@1.7.0(magicast@0.3.5)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))':
     dependencies:
       '@nuxt/kit': 3.15.4(magicast@0.3.5)
@@ -15470,6 +15577,100 @@ snapshots:
       - utf-8-validate
       - vue
 
+  '@nuxt/devtools@1.7.0(rollup@4.41.1)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))(vue@3.5.13(typescript@5.8.3))':
+    dependencies:
+      '@antfu/utils': 0.7.10
+      '@nuxt/devtools-kit': 1.7.0(magicast@0.3.5)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))
+      '@nuxt/devtools-wizard': 1.7.0
+      '@nuxt/kit': 3.15.4(magicast@0.3.5)
+      '@vue/devtools-core': 7.6.8(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))(vue@3.5.13(typescript@5.8.3))
+      '@vue/devtools-kit': 7.6.8
+      birpc: 0.2.19
+      consola: 3.4.2
+      cronstrue: 2.56.0
+      destr: 2.0.3
+      error-stack-parser-es: 0.1.5
+      execa: 7.2.0
+      fast-npm-meta: 0.2.2
+      flatted: 3.3.3
+      get-port-please: 3.1.2
+      hookable: 5.5.3
+      image-meta: 0.2.1
+      is-installed-globally: 1.0.0
+      launch-editor: 2.10.0
+      local-pkg: 0.5.1
+      magicast: 0.3.5
+      nypm: 0.4.1
+      ohash: 1.1.6
+      pathe: 1.1.2
+      perfect-debounce: 1.0.0
+      pkg-types: 1.3.1
+      rc9: 2.1.2
+      scule: 1.3.0
+      semver: 7.7.2
+      simple-git: 3.27.0
+      sirv: 3.0.1
+      tinyglobby: 0.2.12
+      unimport: 3.14.6(rollup@4.41.1)
+      vite: 5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+      vite-plugin-inspect: 0.8.9(@nuxt/kit@3.15.4(magicast@0.3.5))(rollup@4.41.1)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))
+      vite-plugin-vue-inspector: 5.3.1(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))
+      which: 3.0.1
+      ws: 8.18.1
+    transitivePeerDependencies:
+      - bufferutil
+      - rollup
+      - supports-color
+      - utf-8-validate
+      - vue
+
+  '@nuxt/devtools@1.7.0(rollup@4.46.2)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))':
+    dependencies:
+      '@antfu/utils': 0.7.10
+      '@nuxt/devtools-kit': 1.7.0(magicast@0.3.5)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+      '@nuxt/devtools-wizard': 1.7.0
+      '@nuxt/kit': 3.15.4(magicast@0.3.5)
+      '@vue/devtools-core': 7.6.8(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))
+      '@vue/devtools-kit': 7.6.8
+      birpc: 0.2.19
+      consola: 3.4.2
+      cronstrue: 2.56.0
+      destr: 2.0.3
+      error-stack-parser-es: 0.1.5
+      execa: 7.2.0
+      fast-npm-meta: 0.2.2
+      flatted: 3.3.3
+      get-port-please: 3.1.2
+      hookable: 5.5.3
+      image-meta: 0.2.1
+      is-installed-globally: 1.0.0
+      launch-editor: 2.10.0
+      local-pkg: 0.5.1
+      magicast: 0.3.5
+      nypm: 0.4.1
+      ohash: 1.1.6
+      pathe: 1.1.2
+      perfect-debounce: 1.0.0
+      pkg-types: 1.3.1
+      rc9: 2.1.2
+      scule: 1.3.0
+      semver: 7.7.2
+      simple-git: 3.27.0
+      sirv: 3.0.1
+      tinyglobby: 0.2.12
+      unimport: 3.14.6(rollup@4.46.2)
+      vite: 6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+      vite-plugin-inspect: 0.8.9(@nuxt/kit@3.15.4(magicast@0.3.5))(rollup@4.46.2)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+      vite-plugin-vue-inspector: 5.3.1(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+      which: 3.0.1
+      ws: 8.18.1
+    transitivePeerDependencies:
+      - bufferutil
+      - rollup
+      - supports-color
+      - utf-8-validate
+      - vue
+
   '@nuxt/devtools@1.7.0(rollup@4.46.2)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))':
     dependencies:
       '@antfu/utils': 0.7.10
@@ -15544,6 +15745,33 @@ snapshots:
       - rollup
       - supports-color
 
+  '@nuxt/kit@3.14.1592(magicast@0.3.5)(rollup@4.41.1)':
+    dependencies:
+      '@nuxt/schema': 3.14.1592(magicast@0.3.5)(rollup@4.41.1)
+      c12: 2.0.1(magicast@0.3.5)
+      consola: 3.4.2
+      defu: 6.1.4
+      destr: 2.0.3
+      globby: 14.1.0
+      hash-sum: 2.0.0
+      ignore: 6.0.2
+      jiti: 2.4.2
+      klona: 2.0.6
+      knitwork: 1.2.0
+      mlly: 1.7.4
+      pathe: 1.1.2
+      pkg-types: 1.3.1
+      scule: 1.3.0
+      semver: 7.7.2
+      ufo: 1.5.4
+      unctx: 2.4.1
+      unimport: 3.14.6(rollup@4.41.1)
+      untyped: 1.5.2
+    transitivePeerDependencies:
+      - magicast
+      - rollup
+      - supports-color
+
   '@nuxt/kit@3.14.1592(magicast@0.3.5)(rollup@4.46.2)':
     dependencies:
       '@nuxt/schema': 3.14.1592(magicast@0.3.5)(rollup@4.46.2)
@@ -15663,7 +15891,7 @@ snapshots:
       - rollup
       - supports-color
 
-  '@nuxt/schema@3.14.1592(magicast@0.3.5)(rollup@4.46.2)':
+  '@nuxt/schema@3.14.1592(magicast@0.3.5)(rollup@4.41.1)':
     dependencies:
       c12: 2.0.1(magicast@0.3.5)
       compatx: 0.1.8
@@ -15676,18 +15904,38 @@ snapshots:
       std-env: 3.8.1
       ufo: 1.5.4
       uncrypto: 0.1.3
-      unimport: 3.14.6(rollup@4.46.2)
+      unimport: 3.14.6(rollup@4.41.1)
       untyped: 1.5.2
     transitivePeerDependencies:
       - magicast
       - rollup
       - supports-color
 
-  '@nuxt/schema@3.16.2':
+  '@nuxt/schema@3.14.1592(magicast@0.3.5)(rollup@4.46.2)':
     dependencies:
+      c12: 2.0.1(magicast@0.3.5)
+      compatx: 0.1.8
       consola: 3.4.2
       defu: 6.1.4
-      pathe: 2.0.3
+      hookable: 5.5.3
+      pathe: 1.1.2
+      pkg-types: 1.3.1
+      scule: 1.3.0
+      std-env: 3.8.1
+      ufo: 1.5.4
+      uncrypto: 0.1.3
+      unimport: 3.14.6(rollup@4.46.2)
+      untyped: 1.5.2
+    transitivePeerDependencies:
+      - magicast
+      - rollup
+      - supports-color
+
+  '@nuxt/schema@3.16.2':
+    dependencies:
+      consola: 3.4.2
+      defu: 6.1.4
+      pathe: 2.0.3
       std-env: 3.8.1
 
   '@nuxt/telemetry@2.6.5(magicast@0.3.5)':
@@ -15816,6 +16064,66 @@ snapshots:
       - vti
       - vue-tsc
 
+  '@nuxt/vite-builder@3.14.1592(@types/node@22.10.5)(eslint@9.17.0(jiti@2.4.2))(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.41.1)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))':
+    dependencies:
+      '@nuxt/kit': 3.14.1592(magicast@0.3.5)(rollup@4.41.1)
+      '@rollup/plugin-replace': 6.0.2(rollup@4.41.1)
+      '@vitejs/plugin-vue': 5.2.1(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))(vue@3.5.13(typescript@5.8.3))
+      '@vitejs/plugin-vue-jsx': 4.1.1(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))(vue@3.5.13(typescript@5.8.3))
+      autoprefixer: 10.4.20(postcss@8.5.6)
+      clear: 0.1.0
+      consola: 3.4.2
+      cssnano: 7.0.6(postcss@8.5.6)
+      defu: 6.1.4
+      esbuild: 0.24.2
+      escape-string-regexp: 5.0.0
+      estree-walker: 3.0.3
+      externality: 1.0.2
+      get-port-please: 3.1.2
+      h3: 1.15.1
+      jiti: 2.4.2
+      knitwork: 1.2.0
+      magic-string: 0.30.17
+      mlly: 1.7.4
+      ohash: 1.1.6
+      pathe: 1.1.2
+      perfect-debounce: 1.0.0
+      pkg-types: 1.3.1
+      postcss: 8.5.6
+      rollup-plugin-visualizer: 5.14.0(rollup@4.41.1)
+      std-env: 3.8.1
+      strip-literal: 2.1.1
+      ufo: 1.5.4
+      unenv: 1.10.0
+      unplugin: 1.16.1
+      vite: 5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+      vite-node: 2.1.9(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+      vite-plugin-checker: 0.8.0(eslint@9.17.0(jiti@2.4.2))(optionator@0.9.4)(typescript@5.8.3)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))
+      vue: 3.5.13(typescript@5.8.3)
+      vue-bundle-renderer: 2.1.1
+    transitivePeerDependencies:
+      - '@biomejs/biome'
+      - '@types/node'
+      - eslint
+      - less
+      - lightningcss
+      - magicast
+      - meow
+      - optionator
+      - rolldown
+      - rollup
+      - sass
+      - sass-embedded
+      - stylelint
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+      - typescript
+      - vls
+      - vti
+      - vue-tsc
+
   '@nuxt/vite-builder@3.14.1592(@types/node@22.10.5)(eslint@9.17.0(jiti@2.4.2))(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))':
     dependencies:
       '@nuxt/kit': 3.14.1592(magicast@0.3.5)(rollup@4.46.2)
@@ -15943,6 +16251,12 @@ snapshots:
       '@parcel/watcher-win32-ia32': 2.5.1
       '@parcel/watcher-win32-x64': 2.5.1
 
+  '@pinia/colada@0.17.2(pinia@2.3.0(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3))':
+    dependencies:
+      '@vue/devtools-api': 8.0.0
+      pinia: 2.3.0(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))
+      vue: 3.5.13(typescript@5.8.3)
+
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
@@ -17700,9 +18014,9 @@ snapshots:
     dependencies:
       vite: 6.1.0(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
 
-  '@vitejs/plugin-basic-ssl@1.2.0(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))':
+  '@vitejs/plugin-basic-ssl@1.2.0(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))':
     dependencies:
-      vite: 7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+      vite: 6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
 
   '@vitejs/plugin-react@4.4.0-beta.1(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))':
     dependencies:
@@ -17841,7 +18155,7 @@ snapshots:
       '@babel/plugin-syntax-jsx': 7.25.9(@babel/core@7.26.10)
       '@babel/template': 7.26.9
       '@babel/traverse': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
       '@vue/babel-helper-vue-transform-on': 1.4.0
       '@vue/babel-plugin-resolve-type': 1.4.0(@babel/core@7.26.10)
       '@vue/shared': 3.5.18
@@ -17856,7 +18170,7 @@ snapshots:
       '@babel/core': 7.26.10
       '@babel/helper-module-imports': 7.25.9
       '@babel/helper-plugin-utils': 7.26.5
-      '@babel/parser': 7.26.10
+      '@babel/parser': 7.28.3
       '@vue/compiler-sfc': 3.5.18
     transitivePeerDependencies:
       - supports-color
@@ -17932,6 +18246,30 @@ snapshots:
     dependencies:
       '@vue/devtools-kit': 8.0.0
 
+  '@vue/devtools-core@7.6.8(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))(vue@3.5.13(typescript@5.8.3))':
+    dependencies:
+      '@vue/devtools-kit': 7.7.2
+      '@vue/devtools-shared': 7.7.2
+      mitt: 3.0.1
+      nanoid: 5.1.5
+      pathe: 1.1.2
+      vite-hot-client: 0.2.4(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))
+      vue: 3.5.13(typescript@5.8.3)
+    transitivePeerDependencies:
+      - vite
+
+  '@vue/devtools-core@7.6.8(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))':
+    dependencies:
+      '@vue/devtools-kit': 7.7.2
+      '@vue/devtools-shared': 7.7.2
+      mitt: 3.0.1
+      nanoid: 5.1.5
+      pathe: 1.1.2
+      vite-hot-client: 0.2.4(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
+      vue: 3.5.13(typescript@5.8.3)
+    transitivePeerDependencies:
+      - vite
+
   '@vue/devtools-core@7.6.8(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))':
     dependencies:
       '@vue/devtools-kit': 7.7.2
@@ -17949,7 +18287,7 @@ snapshots:
       '@vue/devtools-kit': 7.7.2
       '@vue/devtools-shared': 7.7.2
       mitt: 3.0.1
-      nanoid: 5.1.3
+      nanoid: 5.1.5
       pathe: 2.0.3
       vite-hot-client: 0.2.4(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))
       vue: 3.5.13(typescript@5.8.3)
@@ -18420,7 +18758,7 @@ snapshots:
 
   ast-walker-scope@0.6.2:
     dependencies:
-      '@babel/parser': 7.26.10
+      '@babel/parser': 7.28.3
       ast-kit: 1.4.2
 
   async-function@1.0.0: {}
@@ -18446,7 +18784,7 @@ snapshots:
   autoprefixer@10.4.20(postcss@8.4.41):
     dependencies:
       browserslist: 4.24.4
-      caniuse-lite: 1.0.30001703
+      caniuse-lite: 1.0.30001709
       fraction.js: 4.3.7
       normalize-range: 0.1.2
       picocolors: 1.1.1
@@ -18456,7 +18794,7 @@ snapshots:
   autoprefixer@10.4.20(postcss@8.5.2):
     dependencies:
       browserslist: 4.24.4
-      caniuse-lite: 1.0.30001703
+      caniuse-lite: 1.0.30001709
       fraction.js: 4.3.7
       normalize-range: 0.1.2
       picocolors: 1.1.1
@@ -18466,7 +18804,7 @@ snapshots:
   autoprefixer@10.4.20(postcss@8.5.6):
     dependencies:
       browserslist: 4.24.4
-      caniuse-lite: 1.0.30001703
+      caniuse-lite: 1.0.30001709
       fraction.js: 4.3.7
       normalize-range: 0.1.2
       picocolors: 1.1.1
@@ -18501,7 +18839,7 @@ snapshots:
       '@babel/core': 7.26.9
       find-cache-dir: 4.0.0
       schema-utils: 4.3.0
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   babel-plugin-polyfill-corejs2@0.4.12(@babel/core@7.26.9):
     dependencies:
@@ -18646,7 +18984,7 @@ snapshots:
 
   browserslist@4.24.4:
     dependencies:
-      caniuse-lite: 1.0.30001703
+      caniuse-lite: 1.0.30001709
       electron-to-chromium: 1.5.114
       node-releases: 2.0.19
       update-browserslist-db: 1.1.3(browserslist@4.24.4)
@@ -18768,8 +19106,6 @@ snapshots:
       lodash.memoize: 4.1.2
       lodash.uniq: 4.5.0
 
-  caniuse-lite@1.0.30001703: {}
-
   caniuse-lite@1.0.30001709: {}
 
   ccount@2.0.1: {}
@@ -19048,7 +19384,7 @@ snapshots:
       normalize-path: 3.0.0
       schema-utils: 4.3.0
       serialize-javascript: 6.0.2
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   core-js-compat@3.41.0:
     dependencies:
@@ -19120,7 +19456,7 @@ snapshots:
       postcss-value-parser: 4.2.0
       semver: 7.7.2
     optionalDependencies:
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   css-select@5.1.0:
     dependencies:
@@ -19790,8 +20126,8 @@ snapshots:
       '@typescript-eslint/parser': 8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3)
       eslint: 9.17.0(jiti@2.4.2)
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2))
-      eslint-plugin-import: 2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2))
+      eslint-import-resolver-typescript: 3.8.5(eslint-plugin-import@2.31.0)(eslint@9.17.0(jiti@2.4.2))
+      eslint-plugin-import: 2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-typescript@3.8.5)(eslint@9.17.0(jiti@2.4.2))
       eslint-plugin-jsx-a11y: 6.10.2(eslint@9.17.0(jiti@2.4.2))
       eslint-plugin-react: 7.37.4(eslint@9.17.0(jiti@2.4.2))
       eslint-plugin-react-hooks: 5.2.0(eslint@9.17.0(jiti@2.4.2))
@@ -19814,7 +20150,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)):
+  eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0)(eslint@9.17.0(jiti@2.4.2)):
     dependencies:
       '@nolyfill/is-core-module': 1.0.39
       debug: 4.4.0(supports-color@9.4.0)
@@ -19825,22 +20161,22 @@ snapshots:
       stable-hash: 0.0.4
       tinyglobby: 0.2.12
     optionalDependencies:
-      eslint-plugin-import: 2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2))
+      eslint-plugin-import: 2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-typescript@3.8.5)(eslint@9.17.0(jiti@2.4.2))
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)):
+  eslint-module-utils@2.12.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.8.5)(eslint@9.17.0(jiti@2.4.2)):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
       '@typescript-eslint/parser': 8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3)
       eslint: 9.17.0(jiti@2.4.2)
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2))
+      eslint-import-resolver-typescript: 3.8.5(eslint-plugin-import@2.31.0)(eslint@9.17.0(jiti@2.4.2))
     transitivePeerDependencies:
       - supports-color
 
-  eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)):
+  eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-typescript@3.8.5)(eslint@9.17.0(jiti@2.4.2)):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.8
@@ -19851,7 +20187,7 @@ snapshots:
       doctrine: 2.1.0
       eslint: 9.17.0(jiti@2.4.2)
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.8.5(eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2)))(eslint@9.17.0(jiti@2.4.2))
+      eslint-module-utils: 2.12.0(@typescript-eslint/parser@8.29.1(eslint@9.17.0(jiti@2.4.2))(typescript@5.8.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.8.5)(eslint@9.17.0(jiti@2.4.2))
       hasown: 2.0.2
       is-core-module: 2.16.1
       is-glob: 4.0.3
@@ -19984,7 +20320,7 @@ snapshots:
       natural-compare: 1.4.0
       nth-check: 2.1.1
       postcss-selector-parser: 6.1.2
-      semver: 7.7.1
+      semver: 7.7.2
       vue-eslint-parser: 9.4.3(eslint@9.17.0(jiti@2.4.2))
       xml-name-validator: 4.0.0
     transitivePeerDependencies:
@@ -20943,6 +21279,16 @@ snapshots:
     transitivePeerDependencies:
       - rollup
 
+  impound@0.2.2(rollup@4.41.1):
+    dependencies:
+      '@rollup/pluginutils': 5.1.4(rollup@4.41.1)
+      mlly: 1.7.4
+      mocked-exports: 0.1.1
+      pathe: 2.0.3
+      unplugin: 2.3.2
+    transitivePeerDependencies:
+      - rollup
+
   impound@0.2.2(rollup@4.46.2):
     dependencies:
       '@rollup/pluginutils': 5.1.4(rollup@4.46.2)
@@ -21234,7 +21580,7 @@ snapshots:
   istanbul-lib-instrument@6.0.3:
     dependencies:
       '@babel/core': 7.26.10
-      '@babel/parser': 7.26.10
+      '@babel/parser': 7.28.3
       '@istanbuljs/schema': 0.1.3
       istanbul-lib-coverage: 3.2.2
       semver: 7.7.2
@@ -21512,7 +21858,7 @@ snapshots:
     dependencies:
       less: 4.2.2
     optionalDependencies:
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   less@4.2.2:
     dependencies:
@@ -21537,7 +21883,7 @@ snapshots:
     dependencies:
       webpack-sources: 3.2.3
     optionalDependencies:
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   light-my-request@6.6.0:
     dependencies:
@@ -21739,8 +22085,8 @@ snapshots:
 
   magicast@0.3.5:
     dependencies:
-      '@babel/parser': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/parser': 7.28.3
+      '@babel/types': 7.28.2
       source-map-js: 1.2.1
 
   make-dir@2.1.0:
@@ -22060,7 +22406,7 @@ snapshots:
     dependencies:
       schema-utils: 4.3.0
       tapable: 2.2.1
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   minimalistic-assert@1.0.1: {}
 
@@ -22214,10 +22560,6 @@ snapshots:
 
   nanoid@3.3.11: {}
 
-  nanoid@3.3.9: {}
-
-  nanoid@5.1.3: {}
-
   nanoid@5.1.5: {}
 
   nanotar@0.1.1: {}
@@ -22632,6 +22974,246 @@ snapshots:
       - vue-tsc
       - xml2js
 
+  nuxt@3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.41.1)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)):
+    dependencies:
+      '@nuxt/devalue': 2.0.2
+      '@nuxt/devtools': 1.7.0(rollup@4.41.1)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0))(vue@3.5.13(typescript@5.8.3))
+      '@nuxt/kit': 3.14.1592(magicast@0.3.5)(rollup@4.41.1)
+      '@nuxt/schema': 3.14.1592(magicast@0.3.5)(rollup@4.41.1)
+      '@nuxt/telemetry': 2.6.5(magicast@0.3.5)
+      '@nuxt/vite-builder': 3.14.1592(@types/node@22.10.5)(eslint@9.17.0(jiti@2.4.2))(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.41.1)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))
+      '@unhead/dom': 1.11.20
+      '@unhead/shared': 1.11.20
+      '@unhead/ssr': 1.11.20
+      '@unhead/vue': 1.11.20(vue@3.5.13(typescript@5.8.3))
+      '@vue/shared': 3.5.18
+      acorn: 8.14.0
+      c12: 2.0.1(magicast@0.3.5)
+      chokidar: 4.0.3
+      compatx: 0.1.8
+      consola: 3.4.2
+      cookie-es: 1.2.2
+      defu: 6.1.4
+      destr: 2.0.3
+      devalue: 5.1.1
+      errx: 0.1.0
+      esbuild: 0.24.2
+      escape-string-regexp: 5.0.0
+      estree-walker: 3.0.3
+      globby: 14.1.0
+      h3: 1.15.1
+      hookable: 5.5.3
+      ignore: 6.0.2
+      impound: 0.2.2(rollup@4.41.1)
+      jiti: 2.4.2
+      klona: 2.0.6
+      knitwork: 1.2.0
+      magic-string: 0.30.17
+      mlly: 1.7.4
+      nanotar: 0.1.1
+      nitropack: 2.11.6(encoding@0.1.13)(typescript@5.8.3)
+      nuxi: 3.22.5
+      nypm: 0.3.12
+      ofetch: 1.4.1
+      ohash: 1.1.6
+      pathe: 1.1.2
+      perfect-debounce: 1.0.0
+      pkg-types: 1.3.1
+      radix3: 1.1.2
+      scule: 1.3.0
+      semver: 7.7.2
+      std-env: 3.8.1
+      strip-literal: 2.1.1
+      tinyglobby: 0.2.10
+      ufo: 1.5.4
+      ultrahtml: 1.5.3
+      uncrypto: 0.1.3
+      unctx: 2.4.1
+      unenv: 1.10.0
+      unhead: 1.11.20
+      unimport: 3.14.6(rollup@4.41.1)
+      unplugin: 1.16.1
+      unplugin-vue-router: 0.10.9(rollup@4.41.1)(vue-router@4.5.0(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3))
+      unstorage: 1.15.0(db0@0.3.1)(ioredis@5.6.0)
+      untyped: 1.5.2
+      vue: 3.5.13(typescript@5.8.3)
+      vue-bundle-renderer: 2.1.1
+      vue-devtools-stub: 0.1.0
+      vue-router: 4.5.0(vue@3.5.13(typescript@5.8.3))
+    optionalDependencies:
+      '@parcel/watcher': 2.5.1
+      '@types/node': 22.10.5
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@biomejs/biome'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@electric-sql/pglite'
+      - '@libsql/client'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/kv'
+      - aws4fetch
+      - better-sqlite3
+      - bufferutil
+      - db0
+      - drizzle-orm
+      - encoding
+      - eslint
+      - idb-keyval
+      - ioredis
+      - less
+      - lightningcss
+      - magicast
+      - meow
+      - mysql2
+      - optionator
+      - rolldown
+      - rollup
+      - sass
+      - sass-embedded
+      - sqlite3
+      - stylelint
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - vite
+      - vls
+      - vti
+      - vue-tsc
+      - xml2js
+
+  nuxt@3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
+    dependencies:
+      '@nuxt/devalue': 2.0.2
+      '@nuxt/devtools': 1.7.0(rollup@4.46.2)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0))(vue@3.5.13(typescript@5.8.3))
+      '@nuxt/kit': 3.14.1592(magicast@0.3.5)(rollup@4.46.2)
+      '@nuxt/schema': 3.14.1592(magicast@0.3.5)(rollup@4.46.2)
+      '@nuxt/telemetry': 2.6.5(magicast@0.3.5)
+      '@nuxt/vite-builder': 3.14.1592(@types/node@22.10.5)(eslint@9.17.0(jiti@2.4.2))(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vue@3.5.13(typescript@5.8.3))
+      '@unhead/dom': 1.11.20
+      '@unhead/shared': 1.11.20
+      '@unhead/ssr': 1.11.20
+      '@unhead/vue': 1.11.20(vue@3.5.13(typescript@5.8.3))
+      '@vue/shared': 3.5.18
+      acorn: 8.14.0
+      c12: 2.0.1(magicast@0.3.5)
+      chokidar: 4.0.3
+      compatx: 0.1.8
+      consola: 3.4.2
+      cookie-es: 1.2.2
+      defu: 6.1.4
+      destr: 2.0.3
+      devalue: 5.1.1
+      errx: 0.1.0
+      esbuild: 0.24.2
+      escape-string-regexp: 5.0.0
+      estree-walker: 3.0.3
+      globby: 14.1.0
+      h3: 1.15.1
+      hookable: 5.5.3
+      ignore: 6.0.2
+      impound: 0.2.2(rollup@4.46.2)
+      jiti: 2.4.2
+      klona: 2.0.6
+      knitwork: 1.2.0
+      magic-string: 0.30.17
+      mlly: 1.7.4
+      nanotar: 0.1.1
+      nitropack: 2.11.6(encoding@0.1.13)(typescript@5.8.3)
+      nuxi: 3.22.5
+      nypm: 0.3.12
+      ofetch: 1.4.1
+      ohash: 1.1.6
+      pathe: 1.1.2
+      perfect-debounce: 1.0.0
+      pkg-types: 1.3.1
+      radix3: 1.1.2
+      scule: 1.3.0
+      semver: 7.7.2
+      std-env: 3.8.1
+      strip-literal: 2.1.1
+      tinyglobby: 0.2.10
+      ufo: 1.5.4
+      ultrahtml: 1.5.3
+      uncrypto: 0.1.3
+      unctx: 2.4.1
+      unenv: 1.10.0
+      unhead: 1.11.20
+      unimport: 3.14.6(rollup@4.46.2)
+      unplugin: 1.16.1
+      unplugin-vue-router: 0.10.9(rollup@4.46.2)(vue-router@4.5.0(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3))
+      unstorage: 1.15.0(db0@0.3.1)(ioredis@5.6.0)
+      untyped: 1.5.2
+      vue: 3.5.13(typescript@5.8.3)
+      vue-bundle-renderer: 2.1.1
+      vue-devtools-stub: 0.1.0
+      vue-router: 4.5.0(vue@3.5.13(typescript@5.8.3))
+    optionalDependencies:
+      '@parcel/watcher': 2.5.1
+      '@types/node': 22.10.5
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@biomejs/biome'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@electric-sql/pglite'
+      - '@libsql/client'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/kv'
+      - aws4fetch
+      - better-sqlite3
+      - bufferutil
+      - db0
+      - drizzle-orm
+      - encoding
+      - eslint
+      - idb-keyval
+      - ioredis
+      - less
+      - lightningcss
+      - magicast
+      - meow
+      - mysql2
+      - optionator
+      - rolldown
+      - rollup
+      - sass
+      - sass-embedded
+      - sqlite3
+      - stylelint
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - vite
+      - vls
+      - vti
+      - vue-tsc
+      - xml2js
+
   nuxt@3.14.1592(@parcel/watcher@2.5.1)(@types/node@22.10.5)(db0@0.3.1)(encoding@0.1.13)(eslint@9.17.0(jiti@2.4.2))(ioredis@5.6.0)(less@4.2.2)(magicast@0.3.5)(optionator@0.9.4)(rollup@4.46.2)(sass@1.85.0)(terser@5.39.0)(typescript@5.8.3)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
     dependencies:
       '@nuxt/devalue': 2.0.2
@@ -23285,7 +23867,7 @@ snapshots:
       postcss: 8.5.2
       semver: 7.7.2
     optionalDependencies:
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
     transitivePeerDependencies:
       - typescript
 
@@ -23468,7 +24050,7 @@ snapshots:
 
   postcss@8.5.2:
     dependencies:
-      nanoid: 3.3.9
+      nanoid: 3.3.11
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
@@ -24118,7 +24700,7 @@ snapshots:
       neo-async: 2.6.2
     optionalDependencies:
       sass: 1.85.0
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   sass@1.85.0:
     dependencies:
@@ -24463,7 +25045,7 @@ snapshots:
     dependencies:
       iconv-lite: 0.6.3
       source-map-js: 1.2.1
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   source-map-support@0.5.21:
     dependencies:
@@ -24846,16 +25428,16 @@ snapshots:
 
   term-size@2.2.1: {}
 
-  terser-webpack-plugin@5.3.14(esbuild@0.25.2)(webpack@5.98.0(esbuild@0.25.0)):
+  terser-webpack-plugin@5.3.14(esbuild@0.25.0)(webpack@5.98.0(esbuild@0.25.2)):
     dependencies:
       '@jridgewell/trace-mapping': 0.3.25
       jest-worker: 27.5.1
       schema-utils: 4.3.0
       serialize-javascript: 6.0.2
       terser: 5.39.0
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
     optionalDependencies:
-      esbuild: 0.25.2
+      esbuild: 0.25.0
 
   terser@5.39.0:
     dependencies:
@@ -25045,32 +25627,32 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  turbo-darwin-64@2.5.5:
+  turbo-darwin-64@2.5.6:
     optional: true
 
-  turbo-darwin-arm64@2.5.5:
+  turbo-darwin-arm64@2.5.6:
     optional: true
 
-  turbo-linux-64@2.5.5:
+  turbo-linux-64@2.5.6:
     optional: true
 
-  turbo-linux-arm64@2.5.5:
+  turbo-linux-arm64@2.5.6:
     optional: true
 
-  turbo-windows-64@2.5.5:
+  turbo-windows-64@2.5.6:
     optional: true
 
-  turbo-windows-arm64@2.5.5:
+  turbo-windows-arm64@2.5.6:
     optional: true
 
-  turbo@2.5.5:
+  turbo@2.5.6:
     optionalDependencies:
-      turbo-darwin-64: 2.5.5
-      turbo-darwin-arm64: 2.5.5
-      turbo-linux-64: 2.5.5
-      turbo-linux-arm64: 2.5.5
-      turbo-windows-64: 2.5.5
-      turbo-windows-arm64: 2.5.5
+      turbo-darwin-64: 2.5.6
+      turbo-darwin-arm64: 2.5.6
+      turbo-linux-64: 2.5.6
+      turbo-linux-arm64: 2.5.6
+      turbo-windows-64: 2.5.6
+      turbo-windows-arm64: 2.5.6
 
   type-check@0.4.0:
     dependencies:
@@ -25272,6 +25854,25 @@ snapshots:
     transitivePeerDependencies:
       - rollup
 
+  unimport@3.14.6(rollup@4.41.1):
+    dependencies:
+      '@rollup/pluginutils': 5.1.4(rollup@4.41.1)
+      acorn: 8.14.1
+      escape-string-regexp: 5.0.0
+      estree-walker: 3.0.3
+      fast-glob: 3.3.3
+      local-pkg: 1.1.1
+      magic-string: 0.30.17
+      mlly: 1.7.4
+      pathe: 2.0.3
+      picomatch: 4.0.2
+      pkg-types: 1.3.1
+      scule: 1.3.0
+      strip-literal: 2.1.1
+      unplugin: 1.16.1
+    transitivePeerDependencies:
+      - rollup
+
   unimport@3.14.6(rollup@4.46.2):
     dependencies:
       '@rollup/pluginutils': 5.1.4(rollup@4.46.2)
@@ -25377,7 +25978,7 @@ snapshots:
 
   unplugin-vue-router@0.10.9(rollup@3.29.5)(vue-router@4.5.0(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3)):
     dependencies:
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
       '@rollup/pluginutils': 5.1.4(rollup@3.29.5)
       '@vue-macros/common': 1.16.1(vue@3.5.13(typescript@5.8.3))
       ast-walker-scope: 0.6.2
@@ -25397,9 +25998,31 @@ snapshots:
       - rollup
       - vue
 
+  unplugin-vue-router@0.10.9(rollup@4.41.1)(vue-router@4.5.0(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3)):
+    dependencies:
+      '@babel/types': 7.28.2
+      '@rollup/pluginutils': 5.1.4(rollup@4.41.1)
+      '@vue-macros/common': 1.16.1(vue@3.5.13(typescript@5.8.3))
+      ast-walker-scope: 0.6.2
+      chokidar: 3.6.0
+      fast-glob: 3.3.3
+      json5: 2.2.3
+      local-pkg: 0.5.1
+      magic-string: 0.30.17
+      mlly: 1.7.4
+      pathe: 1.1.2
+      scule: 1.3.0
+      unplugin: 2.0.0-beta.1
+      yaml: 2.8.0
+    optionalDependencies:
+      vue-router: 4.5.0(vue@3.5.13(typescript@5.8.3))
+    transitivePeerDependencies:
+      - rollup
+      - vue
+
   unplugin-vue-router@0.10.9(rollup@4.46.2)(vue-router@4.5.0(vue@3.5.13(typescript@5.8.3)))(vue@3.5.13(typescript@5.8.3)):
     dependencies:
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
       '@rollup/pluginutils': 5.1.4(rollup@4.46.2)
       '@vue-macros/common': 1.16.1(vue@3.5.13(typescript@5.8.3))
       ast-walker-scope: 0.6.2
@@ -25464,7 +26087,7 @@ snapshots:
     dependencies:
       '@babel/core': 7.26.10
       '@babel/standalone': 7.26.10
-      '@babel/types': 7.26.10
+      '@babel/types': 7.28.2
       citty: 0.1.6
       defu: 6.1.4
       jiti: 2.4.2
@@ -25561,6 +26184,14 @@ snapshots:
       '@types/unist': 3.0.3
       vfile-message: 4.0.2
 
+  vite-hot-client@0.2.4(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)):
+    dependencies:
+      vite: 5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+
+  vite-hot-client@0.2.4(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
+    dependencies:
+      vite: 6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+
   vite-hot-client@0.2.4(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
     dependencies:
       vite: 7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
@@ -25633,7 +26264,7 @@ snapshots:
       debug: 4.4.0(supports-color@9.4.0)
       error-stack-parser-es: 0.1.5
       fs-extra: 11.3.0
-      open: 10.1.0
+      open: 10.1.2
       perfect-debounce: 1.0.0
       picocolors: 1.1.1
       sirv: 3.0.1
@@ -25644,6 +26275,42 @@ snapshots:
       - rollup
       - supports-color
 
+  vite-plugin-inspect@0.8.9(@nuxt/kit@3.15.4(magicast@0.3.5))(rollup@4.41.1)(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)):
+    dependencies:
+      '@antfu/utils': 0.7.10
+      '@rollup/pluginutils': 5.1.4(rollup@4.41.1)
+      debug: 4.4.0(supports-color@9.4.0)
+      error-stack-parser-es: 0.1.5
+      fs-extra: 11.3.0
+      open: 10.1.2
+      perfect-debounce: 1.0.0
+      picocolors: 1.1.1
+      sirv: 3.0.1
+      vite: 5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+    optionalDependencies:
+      '@nuxt/kit': 3.15.4(magicast@0.3.5)
+    transitivePeerDependencies:
+      - rollup
+      - supports-color
+
+  vite-plugin-inspect@0.8.9(@nuxt/kit@3.15.4(magicast@0.3.5))(rollup@4.46.2)(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
+    dependencies:
+      '@antfu/utils': 0.7.10
+      '@rollup/pluginutils': 5.1.4(rollup@4.46.2)
+      debug: 4.4.0(supports-color@9.4.0)
+      error-stack-parser-es: 0.1.5
+      fs-extra: 11.3.0
+      open: 10.1.2
+      perfect-debounce: 1.0.0
+      picocolors: 1.1.1
+      sirv: 3.0.1
+      vite: 6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+    optionalDependencies:
+      '@nuxt/kit': 3.15.4(magicast@0.3.5)
+    transitivePeerDependencies:
+      - rollup
+      - supports-color
+
   vite-plugin-inspect@0.8.9(@nuxt/kit@3.15.4(magicast@0.3.5))(rollup@4.46.2)(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
     dependencies:
       '@antfu/utils': 0.7.10
@@ -25651,7 +26318,7 @@ snapshots:
       debug: 4.4.0(supports-color@9.4.0)
       error-stack-parser-es: 0.1.5
       fs-extra: 11.3.0
-      open: 10.1.0
+      open: 10.1.2
       perfect-debounce: 1.0.0
       picocolors: 1.1.1
       sirv: 3.0.1
@@ -25678,6 +26345,36 @@ snapshots:
       - supports-color
       - vue
 
+  vite-plugin-vue-inspector@5.3.1(vite@5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)):
+    dependencies:
+      '@babel/core': 7.26.10
+      '@babel/plugin-proposal-decorators': 7.25.9(@babel/core@7.26.10)
+      '@babel/plugin-syntax-import-attributes': 7.26.0(@babel/core@7.26.10)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.26.10)
+      '@babel/plugin-transform-typescript': 7.26.8(@babel/core@7.26.10)
+      '@vue/babel-plugin-jsx': 1.4.0(@babel/core@7.26.10)
+      '@vue/compiler-dom': 3.5.18
+      kolorist: 1.8.0
+      magic-string: 0.30.17
+      vite: 5.4.19(@types/node@22.10.5)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)
+    transitivePeerDependencies:
+      - supports-color
+
+  vite-plugin-vue-inspector@5.3.1(vite@6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
+    dependencies:
+      '@babel/core': 7.26.10
+      '@babel/plugin-proposal-decorators': 7.25.9(@babel/core@7.26.10)
+      '@babel/plugin-syntax-import-attributes': 7.26.0(@babel/core@7.26.10)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.26.10)
+      '@babel/plugin-transform-typescript': 7.26.8(@babel/core@7.26.10)
+      '@vue/babel-plugin-jsx': 1.4.0(@babel/core@7.26.10)
+      '@vue/compiler-dom': 3.5.18
+      kolorist: 1.8.0
+      magic-string: 0.30.17
+      vite: 6.2.7(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)
+    transitivePeerDependencies:
+      - supports-color
+
   vite-plugin-vue-inspector@5.3.1(vite@7.1.2(@types/node@22.10.5)(jiti@2.4.2)(less@4.2.2)(sass@1.85.0)(terser@5.39.0)(yaml@2.8.0)):
     dependencies:
       '@babel/core': 7.26.10
@@ -26003,7 +26700,7 @@ snapshots:
 
   webidl-conversions@7.0.0: {}
 
-  webpack-dev-middleware@7.4.2(webpack@5.98.0(esbuild@0.25.0)):
+  webpack-dev-middleware@7.4.2(webpack@5.98.0(esbuild@0.25.2)):
     dependencies:
       colorette: 2.0.20
       memfs: 4.17.0
@@ -26012,9 +26709,9 @@ snapshots:
       range-parser: 1.2.1
       schema-utils: 4.3.0
     optionalDependencies:
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
-  webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.0)):
+  webpack-dev-server@5.2.0(webpack@5.98.0(esbuild@0.25.2)):
     dependencies:
       '@types/bonjour': 3.5.13
       '@types/connect-history-api-fallback': 1.5.4
@@ -26034,17 +26731,17 @@ snapshots:
       http-proxy-middleware: 2.0.7(@types/express@4.17.21)
       ipaddr.js: 2.2.0
       launch-editor: 2.10.0
-      open: 10.1.0
+      open: 10.1.2
       p-retry: 6.2.1
       schema-utils: 4.3.0
       selfsigned: 2.4.1
       serve-index: 1.9.1
       sockjs: 0.3.24
       spdy: 4.0.2
-      webpack-dev-middleware: 7.4.2(webpack@5.98.0(esbuild@0.25.0))
+      webpack-dev-middleware: 7.4.2(webpack@5.98.0(esbuild@0.25.2))
       ws: 8.18.1
     optionalDependencies:
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
     transitivePeerDependencies:
       - bufferutil
       - debug
@@ -26062,11 +26759,11 @@ snapshots:
   webpack-subresource-integrity@5.1.0(webpack@5.98.0(esbuild@0.25.0)):
     dependencies:
       typed-assert: 1.0.9
-      webpack: 5.98.0(esbuild@0.25.2)
+      webpack: 5.98.0(esbuild@0.25.0)
 
   webpack-virtual-modules@0.6.2: {}
 
-  webpack@5.98.0(esbuild@0.25.2):
+  webpack@5.98.0(esbuild@0.25.0):
     dependencies:
       '@types/eslint-scope': 3.7.7
       '@types/estree': 1.0.6
@@ -26088,7 +26785,7 @@ snapshots:
       neo-async: 2.6.2
       schema-utils: 4.3.0
       tapable: 2.2.1
-      terser-webpack-plugin: 5.3.14(esbuild@0.25.2)(webpack@5.98.0(esbuild@0.25.0))
+      terser-webpack-plugin: 5.3.14(esbuild@0.25.0)(webpack@5.98.0(esbuild@0.25.2))
       watchpack: 2.4.2
       webpack-sources: 3.2.3
     transitivePeerDependencies: