diff --git a/.changeset/brave-parrots-smell.md b/.changeset/brave-parrots-smell.md
new file mode 100644
index 000000000..679af75ea
--- /dev/null
+++ b/.changeset/brave-parrots-smell.md
@@ -0,0 +1,15 @@
+---
+"@kubb/swagger-tanstack-query": patch
+"@kubb/swagger-client": patch
+"@kubb/swagger-zodios": patch
+"@kubb/swagger-faker": patch
+"@kubb/swagger-msw": patch
+"@kubb/swagger-swr": patch
+"@kubb/swagger-zod": patch
+"@kubb/swagger-ts": patch
+"@kubb/swagger": patch
+"@kubb/react": patch
+"@kubb/core": patch
+---
+
+useOperation and useSchema with a component Oas and Oas.Operation
diff --git a/.changeset/orange-dots-sort.md b/.changeset/orange-dots-sort.md
new file mode 100644
index 000000000..91dc8bfb6
--- /dev/null
+++ b/.changeset/orange-dots-sort.md
@@ -0,0 +1,5 @@
+---
+"@kubb/swagger-zod": patch
+---
+
+use of `useOperationHelpers` to abstract operation logic
diff --git a/docs/plugins/development/system.md b/docs/plugins/development/system.md
index df4fbc8a0..5de17f404 100644
--- a/docs/plugins/development/system.md
+++ b/docs/plugins/development/system.md
@@ -47,7 +47,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
     name: pluginName,
     options,
     pre: [],
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, mode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
 
       return path.resolve(root, output.path, baseName)
@@ -176,7 +176,7 @@ Add some extra functionality to your plugin, here you can even use functions whi
 
 This will be called when pluginManager.resolvePath is called, see [Pluginmanager and resolving a path](/reference/pluginManager/#pluginmanager-resolvepath).
 
-- **Type:** `(this: PluginContext, baseName: string, directory?: string | undefined, options?: object) => KubbFile.OptionalPath` <br/>
+- **Type:** `(this: PluginContext, baseName: string, mode?: 'file' | 'directory', options?: object) => KubbFile.OptionalPath` <br/>
 
 ### resolveName
 
diff --git a/docs/plugins/swagger/hooks/index.md b/docs/plugins/swagger/hooks/index.md
index e4e605736..d53fca1cc 100644
--- a/docs/plugins/swagger/hooks/index.md
+++ b/docs/plugins/swagger/hooks/index.md
@@ -20,7 +20,7 @@ See [Oas](https://github.com/readmeio/oas) to understand how to use the `Oas` in
 import { useOas } from '@kubb/react'
 
 function Component() {
-  const oas = useOas()
+  const { oas } = useOas()
 
   return null
 }
diff --git a/examples/client/templates/client/index.tsx b/examples/client/templates/client/index.tsx
index 4ed2ff7c3..20a4baadd 100644
--- a/examples/client/templates/client/index.tsx
+++ b/examples/client/templates/client/index.tsx
@@ -7,12 +7,12 @@ export const templates = {
     const clientParams = [client.path.template, client.withData ? 'data' : undefined, 'options'].filter(Boolean).join(', ')
 
     return (
-      <Editor language="typescript">
+      <>
         <File.Import name="axios" path="axios" />
         <Function name={name} async export generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
           {`return axios.${client.method}(${clientParams})`}
         </Function>
-      </Editor>
+      </>
     )
   },
 } as const
diff --git a/examples/faker/petStore.yaml b/examples/faker/petStore.yaml
index e81d04f4c..a44084865 100644
--- a/examples/faker/petStore.yaml
+++ b/examples/faker/petStore.yaml
@@ -721,7 +721,7 @@ components:
           example: 1
         nationalityCode:
           type: string
-          pattern: "^[A-Z]{2}$"
+          pattern: ^[A-Z]{2}$
       xml:
         name: user
     Tag:
diff --git a/examples/react-query-v5/kubb.config.ts b/examples/react-query-v5/kubb.config.ts
index d75e99a14..d43d89f90 100644
--- a/examples/react-query-v5/kubb.config.ts
+++ b/examples/react-query-v5/kubb.config.ts
@@ -4,6 +4,7 @@ import createSwaggerTanstackQuery from '@kubb/swagger-tanstack-query'
 import createSwaggerTS from '@kubb/swagger-ts'
 
 import * as queryKey from './templates/queryKey/index'
+import * as operations from './templates/operations/index'
 
 /** @type {import('@kubb/core').UserConfig} */
 export const config = {
@@ -57,6 +58,9 @@ export const config = {
           },
         },
       }],
+      templates: {
+        operations: operations.templates,
+      },
     }),
   ],
 }
diff --git a/examples/react-query-v5/src/gen/hooks/index.ts b/examples/react-query-v5/src/gen/hooks/index.ts
index 3cd1ec1db..3ceb31e1b 100644
--- a/examples/react-query-v5/src/gen/hooks/index.ts
+++ b/examples/react-query-v5/src/gen/hooks/index.ts
@@ -1,3 +1,4 @@
+export * from './operations'
 export * from './useAddPetHook'
 export * from './useCreateUserHook'
 export * from './useCreateUsersWithListInputHook'
diff --git a/examples/react-query-v5/src/gen/hooks/operations.ts b/examples/react-query-v5/src/gen/hooks/operations.ts
new file mode 100644
index 000000000..46c44214f
--- /dev/null
+++ b/examples/react-query-v5/src/gen/hooks/operations.ts
@@ -0,0 +1,60 @@
+export function updatePet() {
+  return '/pet'
+}
+export function addPet() {
+  return '/pet'
+}
+export function findPetsByStatus() {
+  return '/pet/findByStatus'
+}
+export function findPetsByTags() {
+  return '/pet/findByTags'
+}
+export function getPetById() {
+  return '/pet/{petId}'
+}
+export function updatePetWithForm() {
+  return '/pet/{petId}'
+}
+export function deletePet() {
+  return '/pet/{petId}'
+}
+export function uploadFile() {
+  return '/pet/{petId}/uploadImage'
+}
+export function getInventory() {
+  return '/store/inventory'
+}
+export function placeOrder() {
+  return '/store/order'
+}
+export function placeOrderPatch() {
+  return '/store/order'
+}
+export function getOrderById() {
+  return '/store/order/{orderId}'
+}
+export function deleteOrder() {
+  return '/store/order/{orderId}'
+}
+export function createUser() {
+  return '/user'
+}
+export function createUsersWithListInput() {
+  return '/user/createWithList'
+}
+export function loginUser() {
+  return '/user/login'
+}
+export function logoutUser() {
+  return '/user/logout'
+}
+export function getUserByName() {
+  return '/user/{username}'
+}
+export function updateUser() {
+  return '/user/{username}'
+}
+export function deleteUser() {
+  return '/user/{username}'
+}
diff --git a/examples/react-query-v5/src/gen/index.ts b/examples/react-query-v5/src/gen/index.ts
index 6e6f12d44..9d83c2121 100644
--- a/examples/react-query-v5/src/gen/index.ts
+++ b/examples/react-query-v5/src/gen/index.ts
@@ -1,2 +1,2 @@
-export * from './models/index'
 export * from './hooks/index'
+export * from './models/index'
diff --git a/examples/react-query-v5/templates/operations/index.tsx b/examples/react-query-v5/templates/operations/index.tsx
new file mode 100644
index 000000000..fcb10323b
--- /dev/null
+++ b/examples/react-query-v5/templates/operations/index.tsx
@@ -0,0 +1,44 @@
+import { Editor, Function, File, useFile, usePlugin } from '@kubb/react'
+import { useOperations } from '@kubb/swagger/hooks'
+import { Operations } from '@kubb/swagger-tanstack-query/components'
+import React from 'react'
+import { FileMeta, PluginOptions } from '@kubb/swagger-tanstack-query'
+import { Operation } from '@kubb/swagger/oas'
+
+export const templates = {
+  ...Operations.templates,
+  editor: function({ children }: React.ComponentProps<typeof Operations.templates.editor>) {
+    const { key: pluginKey } = usePlugin<PluginOptions>()
+
+    const file = useFile({ name: 'operations', extName: '.ts', pluginKey })
+
+    return (
+      <Editor language="typescript">
+        <File<FileMeta>
+          baseName={file.baseName}
+          path={file.path}
+          meta={file.meta}
+        >
+          <File.Source>
+            {children}
+          </File.Source>
+        </File>
+      </Editor>
+    )
+  },
+  default: function({}: React.ComponentProps<typeof Operations.templates.default>) {
+    const operations = useOperations()
+
+    return (
+      <>
+        {operations.map((item) => {
+          return (
+            <Function name={item.getOperationId()} export>
+              return {JSON.stringify(item.path)}
+            </Function>
+          )
+        })}
+      </>
+    )
+  },
+} as const
diff --git a/examples/react-query-v5/templates/queryKey/index.tsx b/examples/react-query-v5/templates/queryKey/index.tsx
index 097a39360..3c85fef8b 100644
--- a/examples/react-query-v5/templates/queryKey/index.tsx
+++ b/examples/react-query-v5/templates/queryKey/index.tsx
@@ -22,7 +22,7 @@ export const templates = {
     ].filter(Boolean)
 
     return (
-      <Editor language="typescript">
+      <>
         <Function.Arrow name={name} export generics={generics} params={params} returnType={returnType} singleLine JSDoc={JSDoc}>
           {`[${keys}] as const`}
         </Function.Arrow>
@@ -30,7 +30,7 @@ export const templates = {
         <Type name={typeName} export>
           {`ReturnType<typeof ${name}>`}
         </Type>
-      </Editor>
+      </>
     )
   },
 } as const
diff --git a/packages/core/mocks/index.ts b/packages/core/mocks/index.ts
index 11d0f082a..a7d1ee784 100644
--- a/packages/core/mocks/index.ts
+++ b/packages/core/mocks/index.ts
@@ -1,6 +1,8 @@
 import { pascalCase } from '../src/transformers/casing.ts'
 
 import { PluginManager } from '../src/PluginManager.ts'
+import { readSync } from '../src/fs/read.ts'
+
 export const mockedPluginManager = {
   resolveName: ({ name, type }) => {
     if (type === 'type') {
@@ -17,4 +19,23 @@ export const mockedPluginManager = {
     on(eventName, args) {},
     logLevel: 'info',
   },
+  getFile: ({ name, extName, pluginKey }) => {
+    const baseName = `${name}${extName}`
+    let source = ''
+
+    try {
+      source = readSync(baseName)
+    } catch (_e) {
+      //
+    }
+
+    return {
+      path: baseName,
+      baseName,
+      meta: {
+        pluginKey,
+      },
+      source,
+    }
+  },
 } as PluginManager
diff --git a/packages/core/src/PluginManager.ts b/packages/core/src/PluginManager.ts
index f2dfba4ab..c7b485837 100644
--- a/packages/core/src/PluginManager.ts
+++ b/packages/core/src/PluginManager.ts
@@ -2,6 +2,7 @@
 
 import PQueue from 'p-queue'
 
+import { readSync } from './fs/read.ts'
 import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
 import { setUniqueName } from './utils/uniqueName.ts'
@@ -73,6 +74,14 @@ type Events = {
   error: [error: Error]
 }
 
+type GetFileProps<TOptions = object> = {
+  name: string
+  mode?: KubbFile.Mode
+  extName: KubbFile.Extname
+  pluginKey: Plugin['key']
+  options?: TOptions
+}
+
 export class PluginManager {
   readonly plugins: PluginWithLifeCycle[]
   readonly fileManager: FileManager
@@ -118,12 +127,37 @@ export class PluginManager {
     return this
   }
 
+  getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
+    let source = ''
+    const baseName = `${name}${extName}` as const
+    const path = this.resolvePath({ baseName, mode, pluginKey, options })
+
+    if (!path) {
+      throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`)
+    }
+
+    try {
+      source = readSync(path)
+    } catch (_e) {
+      //
+    }
+
+    return {
+      path,
+      baseName,
+      meta: {
+        pluginKey,
+      },
+      source,
+    }
+  }
+
   resolvePath = <TOptions = object>(params: ResolvePathParams<TOptions>): KubbFile.OptionalPath => {
     if (params.pluginKey) {
       const paths = this.hookForPluginSync({
         pluginKey: params.pluginKey,
         hookName: 'resolvePath',
-        parameters: [params.baseName, params.directory, params.options as object],
+        parameters: [params.baseName, params.mode, params.options as object],
       })
 
       if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
@@ -138,7 +172,7 @@ export class PluginManager {
     }
     return this.hookFirstSync({
       hookName: 'resolvePath',
-      parameters: [params.baseName, params.directory, params.options as object],
+      parameters: [params.baseName, params.mode, params.options as object],
     }).result
   }
   resolveName = (params: ResolveNameParams): string => {
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index 230f808b2..fa644df53 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -148,11 +148,6 @@ export type PluginFactoryOptions<
    * When calling `resolvePath` you can specify better types.
    */
   TResolvePathOptions extends object = object,
-  /**
-   * When using @kubb/react(based on React) you can specify here which types should be used when calling render.
-   * Always extend from `AppMeta` of the core.
-   */
-  TAppMeta = unknown,
 > = {
   name: TName
   /**
@@ -165,8 +160,8 @@ export type PluginFactoryOptions<
   resolvePathOptions: TResolvePathOptions
   appMeta: {
     pluginManager: PluginManager
-    plugin: Plugin<PluginFactoryOptions<TName, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>
-  } & TAppMeta
+    plugin: Plugin<PluginFactoryOptions<TName, TOptions, TResolvedOptions, TAPI, TResolvePathOptions>>
+  }
 }
 
 export type GetPluginFactoryOptions<TPlugin extends UserPlugin> = TPlugin extends UserPlugin<infer X> ? X : never
@@ -202,7 +197,7 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
 
 export type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>
 
-type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any, any>>
+type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>
 
 export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
   & {
@@ -254,7 +249,7 @@ export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactor
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    */
-  resolvePath?: (this: PluginContext<TOptions>, baseName: string, directory?: string, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath
+  resolvePath?: (this: PluginContext<TOptions>, baseName: string, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
@@ -293,7 +288,7 @@ export type PluginCache = Record<string, [number, unknown]>
 export type ResolvePathParams<TOptions = object> = {
   pluginKey?: Plugin['key']
   baseName: string
-  directory?: string | undefined
+  mode?: KubbFile.Mode
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
diff --git a/packages/react/src/client/createRoot.ts b/packages/react/src/client/createRoot.ts
index 8cd8b5d83..d6cc9a9f7 100644
--- a/packages/react/src/client/createRoot.ts
+++ b/packages/react/src/client/createRoot.ts
@@ -2,7 +2,7 @@ import { createNode } from '../shared/dom.ts'
 import { ReactTemplate } from '../shared/ReactTemplate.tsx'
 
 import type { Logger } from '@kubb/core/logger'
-import type { AppContextProps } from '../components/AppContext.ts'
+import type { AppContextProps } from '../components/App.tsx'
 import type { DOMElement } from '../types.ts'
 import type { RootType } from './types.ts'
 
diff --git a/packages/react/src/components/App.tsx b/packages/react/src/components/App.tsx
index 75ae745b5..5a3ba77c1 100644
--- a/packages/react/src/components/App.tsx
+++ b/packages/react/src/components/App.tsx
@@ -1,6 +1,4 @@
-import { Component } from 'react'
-
-import { AppContext } from './AppContext.ts'
+import { Component, createContext } from 'react'
 
 import type { Logger } from '@kubb/core/logger'
 import type { KubbNode } from '../types.ts'
@@ -34,6 +32,14 @@ class ErrorBoundary extends Component<{ onError: Props['onError']; logger?: Logg
   }
 }
 
+export type AppContextProps<Meta extends Record<string, unknown> = Record<string, unknown>> = {
+  meta: Meta
+}
+
+const AppContext = createContext<AppContextProps>({
+  meta: {},
+})
+
 export function App<Meta extends Record<string, unknown> = Record<string, unknown>>({ onError, logger, meta, children }: Props<Meta>): KubbNode {
   return (
     <ErrorBoundary logger={logger} onError={onError}>
@@ -41,3 +47,5 @@ export function App<Meta extends Record<string, unknown> = Record<string, unknow
     </ErrorBoundary>
   )
 }
+
+App.Context = AppContext
diff --git a/packages/react/src/components/AppContext.ts b/packages/react/src/components/AppContext.ts
deleted file mode 100644
index 49d88861e..000000000
--- a/packages/react/src/components/AppContext.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { createContext } from 'react'
-
-export type AppContextProps<Meta extends Record<string, unknown> = Record<string, unknown>> = {
-  meta: Meta
-}
-
-export const AppContext = createContext<AppContextProps>({
-  meta: {},
-})
diff --git a/packages/react/src/components/index.ts b/packages/react/src/components/index.ts
index d4abc848f..8eadcb212 100644
--- a/packages/react/src/components/index.ts
+++ b/packages/react/src/components/index.ts
@@ -1,4 +1,4 @@
-export type { AppContextProps } from './AppContext.ts'
+export type { AppContextProps } from './App.tsx'
 export type { EditorLanguage } from './Editor.tsx'
 export { Editor, TypeScript } from './Editor.tsx'
 export { File } from './File.tsx'
diff --git a/packages/react/src/hooks/useApp.ts b/packages/react/src/hooks/useApp.ts
index 26c727462..b01fe7856 100644
--- a/packages/react/src/hooks/useApp.ts
+++ b/packages/react/src/hooks/useApp.ts
@@ -1,9 +1,9 @@
 import { useContext } from 'react'
 
-import { AppContext } from '../components/AppContext.ts'
+import { App } from '../components/App.tsx'
 
-import type { AppContextProps } from '../components/AppContext.ts'
+import type { AppContextProps } from '../components/App.tsx'
 
 export function useApp<Meta extends Record<string, unknown> = Record<string, unknown>>(): AppContextProps<Meta> {
-  return useContext(AppContext) as AppContextProps<Meta>
+  return useContext(App.Context) as AppContextProps<Meta>
 }
diff --git a/packages/react/src/hooks/useFile.ts b/packages/react/src/hooks/useFile.ts
index f7f071256..50b07dead 100644
--- a/packages/react/src/hooks/useFile.ts
+++ b/packages/react/src/hooks/useFile.ts
@@ -1,38 +1,17 @@
-import { readSync } from '@kubb/core/fs'
 import { usePluginManager } from '@kubb/react'
 
 import type { KubbFile, Plugin } from '@kubb/core'
 
 type Props<TOptions = object> = {
   name: string
+  mode?: KubbFile.Mode
   extName: KubbFile.Extname
   pluginKey: Plugin['key']
   options?: TOptions
 }
 
-export function useFile<TOptions = object>({ name, extName, pluginKey, options }: Props<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
+export function useFile<TOptions = object>({ name, mode, extName, pluginKey, options }: Props<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
   const pluginManager = usePluginManager()
 
-  let source = ''
-  const baseName = `${name}${extName}` as const
-  const path = pluginManager.resolvePath({ baseName, pluginKey, options })
-
-  if (!path) {
-    throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`)
-  }
-
-  try {
-    source = readSync(path)
-  } catch (_e) {
-    //
-  }
-
-  return {
-    path,
-    baseName,
-    meta: {
-      pluginKey,
-    },
-    source,
-  }
+  return pluginManager.getFile<TOptions>({ name, mode, extName, pluginKey, options })
 }
diff --git a/packages/react/src/hooks/useMeta.ts b/packages/react/src/hooks/useMeta.ts
index 1003f307f..3cf0f64d8 100644
--- a/packages/react/src/hooks/useMeta.ts
+++ b/packages/react/src/hooks/useMeta.ts
@@ -1,6 +1,6 @@
 import { useApp } from './useApp.ts'
 
-import type { AppContextProps } from '../components/AppContext.ts'
+import type { AppContextProps } from '../components/App.tsx'
 
 export function useMeta<Meta extends Record<string, unknown> = Record<string, unknown>>(): AppContextProps<Meta>['meta'] {
   const app = useApp<Meta>()
diff --git a/packages/react/src/index.ts b/packages/react/src/index.ts
index 9e95040b8..6f504f2d5 100644
--- a/packages/react/src/index.ts
+++ b/packages/react/src/index.ts
@@ -1,5 +1,3 @@
-import React from 'react'
-
 export type { RootType } from './client/index.ts'
 export { createRoot } from './client/index.ts'
 export type { AppContextProps } from './components/index.ts'
@@ -19,5 +17,4 @@ export {
   useResolvePath,
 } from './hooks/index.ts'
 export type * from './types.ts'
-
-export default React
+export { createContext, useContext } from 'react'
diff --git a/packages/react/src/server/createRootServer.ts b/packages/react/src/server/createRootServer.ts
index 607fe619b..867c1095d 100644
--- a/packages/react/src/server/createRootServer.ts
+++ b/packages/react/src/server/createRootServer.ts
@@ -3,7 +3,7 @@ import { ReactTemplate } from '../shared/ReactTemplate.tsx'
 import { format } from './format.ts'
 
 import type { Logger } from '@kubb/core/logger'
-import type { AppContextProps } from '../components/AppContext.ts'
+import type { AppContextProps } from '../components/App.tsx'
 import type { DOMElement } from '../types.ts'
 import type { RootType } from './types.ts'
 
diff --git a/packages/react/src/shared/ReactTemplate.tsx b/packages/react/src/shared/ReactTemplate.tsx
index 1f6d4be23..63b69c750 100644
--- a/packages/react/src/shared/ReactTemplate.tsx
+++ b/packages/react/src/shared/ReactTemplate.tsx
@@ -10,7 +10,7 @@ import { renderer } from './renderer.ts'
 import type { KubbFile } from '@kubb/core'
 import type { Logger } from '@kubb/core/logger'
 import type { ReactNode } from 'react'
-import type { AppContextProps } from '../components/AppContext.ts'
+import type { AppContextProps } from '../components/App.tsx'
 import type { FiberRoot } from '../reconciler.ts'
 import type { DOMElement } from '../types.ts'
 
@@ -106,6 +106,10 @@ export class ReactTemplate<Context extends AppContextProps = AppContextProps> {
     this.#lastFiles = files
   }
   onError(error: Error): void {
+    if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
+      console.error(error)
+    }
+
     if (!this.logger) {
       console.error(error)
     }
diff --git a/packages/swagger-client/src/OperationGenerator.test.tsx b/packages/swagger-client/src/OperationGenerator.test.tsx
index 4ed492398..60542b09a 100644
--- a/packages/swagger-client/src/OperationGenerator.test.tsx
+++ b/packages/swagger-client/src/OperationGenerator.test.tsx
@@ -45,7 +45,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pets/{pet_id}', 'get')
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -78,7 +78,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pets/{pet_id}', 'get')
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -93,6 +93,7 @@ describe('OperationGenerator', async () => {
         operations: Operations.templates,
         client: {
           default: CustomClientTemplate,
+          editor: Client.templates.editor,
         },
       },
       client: {
@@ -113,7 +114,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pets/{pet_id}', 'get')
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
diff --git a/packages/swagger-client/src/OperationGenerator.tsx b/packages/swagger-client/src/OperationGenerator.tsx
index 4f1fafc56..9a2f7915d 100644
--- a/packages/swagger-client/src/OperationGenerator.tsx
+++ b/packages/swagger-client/src/OperationGenerator.tsx
@@ -1,18 +1,19 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Client, Operations } from './components/index.ts'
 
 import type { AppContextProps } from '@kubb/react'
-import type { OperationMethodResult, OperationSchemas, Paths } from '@kubb/swagger'
+import type { OperationMethodResult, OperationsByMethod } from '@kubb/swagger'
 import type { Operation } from '@kubb/swagger/oas'
 import type { FileMeta, PluginOptions } from './types.ts'
 
 export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
-  async all(paths: Paths): OperationMethodResult<FileMeta> {
+  async all(operations: Operation[], operationsByMethod: OperationsByMethod): OperationMethodResult<FileMeta> {
     const { pluginManager, oas, plugin } = this.context
 
-    const root = createRoot<AppContextProps>({ logger: pluginManager.logger })
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
 
     const templates = {
       operations: Operations.templates,
@@ -20,16 +21,17 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
       ...this.options.templates,
     }
 
-    if (!templates.operations) {
-      return []
-    }
-
-    root.render(<Operations.File name="operations" paths={paths} templates={templates.operations} />, { meta: { oas, pluginManager, plugin } })
+    root.render(
+      <Oas oas={oas} operations={operations} getSchemas={(...props) => this.getSchemas(...props)}>
+        {templates.operations && <Operations.File operationsByMethod={operationsByMethod} templates={templates.operations} />}
+      </Oas>,
+      { meta: { pluginManager, plugin } },
+    )
 
     return root.files
   }
 
-  async #generate(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async #generate(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
@@ -44,26 +46,33 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
       return []
     }
 
-    root.render(<Client.File templates={templates.client} />, { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } })
+    root.render(
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Client.File templates={templates.client} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
+    )
 
     return root.files
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
 }
diff --git a/packages/swagger-client/src/components/Client.test.tsx b/packages/swagger-client/src/components/Client.test.tsx
index 9aad9a69c..c51810e81 100644
--- a/packages/swagger-client/src/components/Client.test.tsx
+++ b/packages/swagger-client/src/components/Client.test.tsx
@@ -1,6 +1,7 @@
 import { mockedPluginManager } from '@kubb/core/mocks'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Client } from './Client.tsx'
@@ -43,12 +44,18 @@ describe('<Client/>', async () => {
 
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{pet_id}', 'get')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Client.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Client.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
+
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
 
diff --git a/packages/swagger-client/src/components/Client.tsx b/packages/swagger-client/src/components/Client.tsx
index 5015949d7..bf4997a1a 100644
--- a/packages/swagger-client/src/components/Client.tsx
+++ b/packages/swagger-client/src/components/Client.tsx
@@ -204,4 +204,4 @@ Client.File = function(props: FileProps): KubbNode {
   )
 }
 
-Client.templates = defaultTemplates as Templates
+Client.templates = defaultTemplates
diff --git a/packages/swagger-client/src/components/Operations.test.tsx b/packages/swagger-client/src/components/Operations.test.tsx
index af80424e8..ce4bd6332 100644
--- a/packages/swagger-client/src/components/Operations.test.tsx
+++ b/packages/swagger-client/src/components/Operations.test.tsx
@@ -1,13 +1,14 @@
 import { mockedPluginManager } from '@kubb/core/mocks'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Operations } from './Operations.tsx'
 
 import type { Plugin } from '@kubb/core'
 import type { AppContextProps } from '@kubb/react'
-import type { GetOperationGeneratorOptions, Paths } from '@kubb/swagger'
+import type { GetOperationGeneratorOptions, OperationsByMethod } from '@kubb/swagger'
 import type { PluginOptions } from '../types.ts'
 
 describe('<Operations/>', async () => {
@@ -44,23 +45,28 @@ describe('<Operations/>', async () => {
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{pet_id}', 'get')
     const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
       return (
-        <Operations.File
-          name="operations"
-          paths={{
-            '/pets/{pet_id}': {
-              get: {
-                operation,
-                schemas,
-              },
-            },
-          } as unknown as Paths}
-        />
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Operations.File
+              operationsByMethod={{
+                '/pets/{pet_id}': {
+                  get: {
+                    operation,
+                    schemas,
+                  },
+                },
+              } as unknown as OperationsByMethod}
+            />
+          </Oas.Operation>
+        </Oas>
       )
     }
+
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
 
diff --git a/packages/swagger-client/src/components/Operations.tsx b/packages/swagger-client/src/components/Operations.tsx
index d86a2525e..36b9e307c 100644
--- a/packages/swagger-client/src/components/Operations.tsx
+++ b/packages/swagger-client/src/components/Operations.tsx
@@ -4,7 +4,7 @@ import { useFile } from '@kubb/react'
 import { useOas } from '@kubb/swagger/hooks'
 
 import type { KubbNode } from '@kubb/react'
-import type { Paths } from '@kubb/swagger'
+import type { OperationsByMethod } from '@kubb/swagger'
 import type { HttpMethod, Oas } from '@kubb/swagger/oas'
 import type { ComponentProps, ComponentType } from 'react'
 import type { FileMeta, PluginOptions } from '../types.ts'
@@ -28,13 +28,38 @@ function Template({
   )
 }
 
-const defaultTemplates = { default: Template } as const
+type EditorTemplateProps = {
+  children?: React.ReactNode
+}
+
+function EditorTemplate({ children }: EditorTemplateProps) {
+  const { key: pluginKey } = usePlugin<PluginOptions>()
+  const file = useFile({ name: 'operations', extName: '.ts', pluginKey })
+
+  return (
+    <Editor language="typescript">
+      <File<FileMeta>
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+      >
+        <File.Source>
+          {children}
+        </File.Source>
+      </File>
+    </Editor>
+  )
+}
 
-function getOperations(oas: Oas, paths: Paths): Record<string, { path: string; method: HttpMethod }> {
+const defaultTemplates = { default: Template, editor: EditorTemplate } as const
+
+type Templates = Partial<typeof defaultTemplates>
+
+function getOperations(oas: Oas, operationsByMethod: OperationsByMethod): Record<string, { path: string; method: HttpMethod }> {
   const operations: Record<string, { path: string; method: HttpMethod }> = {}
 
-  Object.keys(paths).forEach((path) => {
-    const methods = paths[path] || []
+  Object.keys(operationsByMethod).forEach((path) => {
+    const methods = operationsByMethod[path] || []
     Object.keys(methods).forEach((method) => {
       const operation = oas.operation(path, method as HttpMethod)
       if (operation) {
@@ -50,7 +75,7 @@ function getOperations(oas: Oas, paths: Paths): Record<string, { path: string; m
 }
 
 type Props = {
-  paths: Paths
+  operationsByMethod: OperationsByMethod
   /**
    * This will make it possible to override the default behaviour.
    */
@@ -58,12 +83,12 @@ type Props = {
 }
 
 export function Operations({
-  paths,
+  operationsByMethod,
   Template = defaultTemplates.default,
 }: Props): KubbNode {
-  const oas = useOas()
+  const { oas } = useOas()
 
-  const operations = getOperations(oas, paths)
+  const operations = getOperations(oas, operationsByMethod)
   return (
     <Template
       name="operations"
@@ -73,32 +98,26 @@ export function Operations({
 }
 
 type FileProps = {
-  name: string
-  paths: Paths
+  /**
+   * @deprecated
+   */
+  operationsByMethod: OperationsByMethod
   /**
    * This will make it possible to override the default behaviour.
    */
-  templates?: typeof defaultTemplates
+  templates?: Templates
 }
 
-Operations.File = function({ name, paths, templates = defaultTemplates }: FileProps): KubbNode {
-  const { key: pluginKey } = usePlugin<PluginOptions>()
-  const file = useFile({ name, extName: '.ts', pluginKey })
+Operations.File = function(props: FileProps): KubbNode {
+  const templates = { ...defaultTemplates, ...props.templates }
 
   const Template = templates.default
+  const EditorTemplate = templates.editor
 
   return (
-    <Editor language="typescript">
-      <File<FileMeta>
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-      >
-        <File.Source>
-          <Operations Template={Template} paths={paths} />
-        </File.Source>
-      </File>
-    </Editor>
+    <EditorTemplate>
+      <Operations Template={Template} operationsByMethod={props.operationsByMethod} />
+    </EditorTemplate>
   )
 }
 
diff --git a/packages/swagger-client/src/plugin.ts b/packages/swagger-client/src/plugin.ts
index e1707ef60..d54c9f55a 100644
--- a/packages/swagger-client/src/plugin.ts
+++ b/packages/swagger-client/src/plugin.ts
@@ -47,9 +47,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       },
     },
     pre: [swaggerPluginName],
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
diff --git a/packages/swagger-client/src/types.ts b/packages/swagger-client/src/types.ts
index 0f0ebb57e..43c25f967 100644
--- a/packages/swagger-client/src/types.ts
+++ b/packages/swagger-client/src/types.ts
@@ -1,5 +1,5 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 import type { Client, Operations } from './components/index.ts'
 
 type Templates = {
@@ -116,9 +116,7 @@ export type FileMeta = {
   tag?: string
 }
 
-type AppMeta = SwaggerAppMeta
-
-export type PluginOptions = PluginFactoryOptions<'swagger-client', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger-client', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-faker/src/OperationGenerator.test.tsx b/packages/swagger-faker/src/OperationGenerator.test.tsx
index 766ed3c53..abcbfcdc7 100644
--- a/packages/swagger-faker/src/OperationGenerator.test.tsx
+++ b/packages/swagger-faker/src/OperationGenerator.test.tsx
@@ -39,8 +39,8 @@ describe('OperationGenerator', async () => {
     const operation = oas.operation('/pets', 'get')
     const operationShowById = oas.operation('/pets/{petId}', 'get')
 
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
-    const getShowByIdFiles = await og.get(operationShowById, og.getSchemas(operationShowById), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
+    const getShowByIdFiles = await og.get(operationShowById, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -75,8 +75,8 @@ describe('OperationGenerator', async () => {
     const operation = oas.operation('/pets', 'get')
     const operationShowById = oas.operation('/pets/{petId}', 'get')
 
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
-    const getShowByIdFiles = await og.get(operationShowById, og.getSchemas(operationShowById), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
+    const getShowByIdFiles = await og.get(operationShowById, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -109,7 +109,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pets', 'post')
-    const files = await og.post(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.post(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -138,7 +138,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pet/{petId}', 'delete')
-    const files = await og.delete(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.delete(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
diff --git a/packages/swagger-faker/src/OperationGenerator.tsx b/packages/swagger-faker/src/OperationGenerator.tsx
index 8b48cb475..f44219c2a 100644
--- a/packages/swagger-faker/src/OperationGenerator.tsx
+++ b/packages/swagger-faker/src/OperationGenerator.tsx
@@ -1,5 +1,6 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Mutation } from './components/Mutation.tsx'
 import { Query } from './components/Query.tsx'
@@ -15,37 +16,45 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     return null
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Query.File />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Query.File />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Mutation.File />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Mutation.File />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
 }
diff --git a/packages/swagger-faker/src/components/Mutation.test.tsx b/packages/swagger-faker/src/components/Mutation.test.tsx
index ca901eb43..c8e0c6bfa 100644
--- a/packages/swagger-faker/src/components/Mutation.test.tsx
+++ b/packages/swagger-faker/src/components/Mutation.test.tsx
@@ -2,6 +2,7 @@ import { mockedPluginManager } from '@kubb/core/mocks'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Mutation } from './Mutation.tsx'
@@ -52,11 +53,16 @@ describe('<Mutation/>', async () => {
 
   test('pets', async () => {
     const operation = oas.operation('/pets', 'post')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Mutation.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Mutation.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
diff --git a/packages/swagger-faker/src/components/Mutation.tsx b/packages/swagger-faker/src/components/Mutation.tsx
index 16e68c573..a83580921 100644
--- a/packages/swagger-faker/src/components/Mutation.tsx
+++ b/packages/swagger-faker/src/components/Mutation.tsx
@@ -30,7 +30,7 @@ Mutation.File = function({}: FileProps): ReactNode {
 
   const schemas = useSchemas()
   const pluginManager = usePluginManager()
-  const oas = useOas()
+  const { oas } = useOas()
   const file = useOperationFile()
 
   const builder = new FakerBuilder(options, { oas, pluginManager })
diff --git a/packages/swagger-faker/src/components/Query.test.tsx b/packages/swagger-faker/src/components/Query.test.tsx
index ee428b225..88b3848d5 100644
--- a/packages/swagger-faker/src/components/Query.test.tsx
+++ b/packages/swagger-faker/src/components/Query.test.tsx
@@ -2,6 +2,7 @@ import { mockedPluginManager } from '@kubb/core/mocks'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Query } from './Query.tsx'
@@ -52,11 +53,16 @@ describe('<Query/>', async () => {
 
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{petId}', 'get')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Query.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Query.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
diff --git a/packages/swagger-faker/src/components/Query.tsx b/packages/swagger-faker/src/components/Query.tsx
index d5d56eb54..f55f64cc6 100644
--- a/packages/swagger-faker/src/components/Query.tsx
+++ b/packages/swagger-faker/src/components/Query.tsx
@@ -30,7 +30,7 @@ Query.File = function({}: FileProps): ReactNode {
 
   const schemas = useSchemas()
   const pluginManager = usePluginManager()
-  const oas = useOas()
+  const { oas } = useOas()
   const file = useOperationFile()
 
   const builder = new FakerBuilder(options, { oas, pluginManager })
diff --git a/packages/swagger-faker/src/plugin.ts b/packages/swagger-faker/src/plugin.ts
index 24e3b9803..5edd4076e 100644
--- a/packages/swagger-faker/src/plugin.ts
+++ b/packages/swagger-faker/src/plugin.ts
@@ -43,9 +43,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       unknownType,
     },
     pre: [swaggerPluginName, swaggerTypeScriptPluginName],
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
diff --git a/packages/swagger-faker/src/types.ts b/packages/swagger-faker/src/types.ts
index c9d7d48da..373dfdfe1 100644
--- a/packages/swagger-faker/src/types.ts
+++ b/packages/swagger-faker/src/types.ts
@@ -1,5 +1,5 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 import type { OasTypes } from '@kubb/swagger/oas'
 import type { FakerMeta } from './fakerParser.ts'
 
@@ -107,9 +107,7 @@ export type FileMeta = {
   tag?: string
 }
 
-type AppMeta = SwaggerAppMeta
-
-export type PluginOptions = PluginFactoryOptions<'swagger-faker', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger-faker', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-msw/src/OperationGenerator.tsx b/packages/swagger-msw/src/OperationGenerator.tsx
index 81a762c4d..ce807645f 100644
--- a/packages/swagger-msw/src/OperationGenerator.tsx
+++ b/packages/swagger-msw/src/OperationGenerator.tsx
@@ -1,42 +1,44 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
-import { Handlers } from './components/Handlers.tsx'
 import { Mock } from './components/Mock.tsx'
+import { Operations } from './components/Operations.tsx'
 
 import type { AppContextProps } from '@kubb/react'
-import type { OperationMethodResult, OperationSchemas, Paths } from '@kubb/swagger'
+import type { OperationMethodResult, OperationsByMethod } from '@kubb/swagger'
 import type { Operation } from '@kubb/swagger/oas'
 import type { FileMeta, PluginOptions } from './types.ts'
 
 export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
-  async all(paths: Paths): OperationMethodResult<FileMeta> {
+  async all(operations: Operation[], operationsByMethod: OperationsByMethod): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
-    const root = createRoot<AppContextProps>({ logger: pluginManager.logger })
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
 
     const templates = {
-      handlers: Handlers.templates,
+      operations: Operations.templates,
       mock: Mock.templates,
       ...this.options.templates,
     }
 
-    if (!templates?.handlers) {
-      return []
-    }
-
-    root.render(<Handlers.File name="handlers" paths={paths} templates={templates.handlers} />, { meta: { oas, pluginManager, plugin } })
+    root.render(
+      <Oas oas={oas} operations={operations} getSchemas={(...props) => this.getSchemas(...props)}>
+        {templates?.operations && <Operations.File operationsByMethod={operationsByMethod} templates={templates.operations} />}
+      </Oas>,
+      { meta: { pluginManager, plugin } },
+    )
 
     return root.files
   }
 
-  async #generate(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async #generate(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
 
     const templates = {
-      handlers: Handlers.templates,
+      handlers: Operations.templates,
       mock: Mock.templates,
       ...options.templates,
     }
@@ -45,26 +47,33 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
       return []
     }
 
-    root.render(<Mock.File templates={templates.mock} />, { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } })
+    root.render(
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Mock.File templates={templates.mock} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
+    )
 
     return root.files
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.#generate(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.#generate(operation, options)
   }
 }
diff --git a/packages/swagger-msw/src/components/Handlers.tsx b/packages/swagger-msw/src/components/Handlers.tsx
deleted file mode 100644
index c1e2abec0..000000000
--- a/packages/swagger-msw/src/components/Handlers.tsx
+++ /dev/null
@@ -1,141 +0,0 @@
-import { Editor, File, usePlugin, usePluginManager } from '@kubb/react'
-import { useFile } from '@kubb/react'
-
-import type { KubbFile, ResolveNameParams, ResolvePathParams } from '@kubb/core'
-import type { Paths } from '@kubb/swagger'
-import type { Operation } from '@kubb/swagger/oas'
-import type { ReactNode } from 'react'
-import type { FileMeta, PluginOptions } from '../types.ts'
-
-type TemplateProps = {
-  /**
-   * Name of the function
-   */
-  name: string
-  handlers: string[]
-}
-
-function Template({
-  name,
-  handlers,
-}: TemplateProps): ReactNode {
-  return (
-    <>
-      {`export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, '')} as const`}
-    </>
-  )
-}
-
-const defaultTemplates = { default: Template } as const
-
-function getHandlers(
-  paths: Paths,
-  { resolveName, pluginKey }: { resolveName: (params: ResolveNameParams) => string; pluginKey: ResolveNameParams['pluginKey'] },
-): Array<{ name: string; operation: Operation }> {
-  const handlers: Array<{ name: string; operation: Operation }> = []
-
-  Object.keys(paths).forEach((path) => {
-    const operations = paths[path]
-    const filteredOperations = [operations?.get, operations?.post, operations?.patch, operations?.put, operations?.delete].filter(Boolean)
-
-    filteredOperations.forEach(({ operation }) => {
-      const operationId = operation.getOperationId()
-      const name = resolveName({ name: operationId, pluginKey, type: 'function' })
-
-      handlers.push({ name, operation })
-    })
-  })
-
-  return handlers
-}
-
-function getHandlersImports(
-  paths: Paths,
-  { resolveName, resolvePath, pluginKey }: {
-    resolveName: (params: ResolveNameParams) => string
-    resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath
-    pluginKey: ResolveNameParams['pluginKey']
-  },
-): Array<{ name: string; path: KubbFile.OptionalPath }> {
-  const handlers = getHandlers(paths, { resolveName, pluginKey })
-
-  return handlers.map(({ name, operation }) => {
-    const path = resolvePath({
-      pluginKey,
-      baseName: `${name}.ts`,
-      options: {
-        tag: operation?.getTags()[0]?.name,
-      },
-    })
-    return { name, path }
-  })
-}
-
-type Props = {
-  paths: Paths
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  Template?: React.ComponentType<React.ComponentProps<typeof Template>>
-}
-
-export function Handlers({
-  paths,
-  Template = defaultTemplates.default,
-}: Props): ReactNode {
-  const { key: pluginKey } = usePlugin<PluginOptions>()
-  const pluginManager = usePluginManager()
-
-  const handlers = getHandlers(paths, { resolveName: pluginManager.resolveName, pluginKey })
-
-  return (
-    <Template
-      name="handlers"
-      handlers={handlers.map(item => item.name)}
-    />
-  )
-}
-
-type FileProps = {
-  name: string
-  paths: Paths
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  templates?: typeof defaultTemplates
-}
-
-Handlers.File = function({ name, paths, templates = defaultTemplates }: FileProps): ReactNode {
-  const pluginManager = usePluginManager()
-  const { key: pluginKey } = usePlugin<PluginOptions>()
-  const file = useFile({ name, extName: '.ts', pluginKey })
-
-  const handlersImports = getHandlersImports(paths, { resolveName: pluginManager.resolveName, resolvePath: pluginManager.resolvePath, pluginKey })
-
-  const imports = handlersImports.map(({ name, path }, index) => {
-    if (!path) {
-      return null
-    }
-
-    return <File.Import key={index} name={[name]} root={file.path} path={path} />
-  }).filter(Boolean)
-
-  const Template = templates.default
-
-  return (
-    <Editor language="typescript">
-      <File<FileMeta>
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-      >
-        {imports}
-        <File.Source>
-          <Handlers Template={Template} paths={paths} />
-        </File.Source>
-      </File>
-    </Editor>
-  )
-}
-
-Handlers.templates = defaultTemplates
diff --git a/packages/swagger-msw/src/components/Mock.test.tsx b/packages/swagger-msw/src/components/Mock.test.tsx
index 5154a5e79..32cbd481f 100644
--- a/packages/swagger-msw/src/components/Mock.test.tsx
+++ b/packages/swagger-msw/src/components/Mock.test.tsx
@@ -1,6 +1,7 @@
 import { mockedPluginManager } from '@kubb/core/mocks'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Mock } from './Mock.tsx'
@@ -39,11 +40,16 @@ describe('<Mock/>', async () => {
 
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{petId}', 'get')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Mock.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Mock.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
@@ -53,12 +59,18 @@ describe('<Mock/>', async () => {
 
   test('pets', async () => {
     const operation = oas.operation('/pets', 'post')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Mock.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Mock.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
+
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
 
diff --git a/packages/swagger-msw/src/components/Operations.tsx b/packages/swagger-msw/src/components/Operations.tsx
new file mode 100644
index 000000000..2fb40c974
--- /dev/null
+++ b/packages/swagger-msw/src/components/Operations.tsx
@@ -0,0 +1,123 @@
+import { Editor, File, usePlugin, usePluginManager } from '@kubb/react'
+import { useFile } from '@kubb/react'
+
+import { getHandlers, getHandlersImports } from './utils.ts'
+
+import type { KubbNode } from '@kubb/react'
+import type { OperationsByMethod } from '@kubb/swagger'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginOptions } from '../types.ts'
+
+type TemplateProps = {
+  /**
+   * Name of the function
+   */
+  name: string
+  handlers: string[]
+}
+
+function Template({
+  name,
+  handlers,
+}: TemplateProps): ReactNode {
+  return (
+    <>
+      {`export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, '')} as const`}
+    </>
+  )
+}
+
+type EditorTemplateProps = {
+  /**
+   * @deprecated
+   */
+  operationsByMethod: OperationsByMethod
+  children?: React.ReactNode
+}
+
+function EditorTemplate({ operationsByMethod, children }: EditorTemplateProps) {
+  const { key: pluginKey } = usePlugin<PluginOptions>()
+  const file = useFile({ name: 'handlers', extName: '.ts', pluginKey })
+
+  const pluginManager = usePluginManager()
+
+  const handlersImports = getHandlersImports(operationsByMethod, { resolveName: pluginManager.resolveName, resolvePath: pluginManager.resolvePath, pluginKey })
+
+  const imports = handlersImports.map(({ name, path }, index) => {
+    if (!path) {
+      return null
+    }
+
+    return <File.Import key={index} name={[name]} root={file.path} path={path} />
+  }).filter(Boolean)
+
+  return (
+    <Editor language="typescript">
+      <File<FileMeta>
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+      >
+        {imports}
+        <File.Source>
+          {children}
+        </File.Source>
+      </File>
+    </Editor>
+  )
+}
+
+const defaultTemplates = { default: Template, editor: EditorTemplate } as const
+
+type Templates = Partial<typeof defaultTemplates>
+
+type Props = {
+  operationsByMethod: OperationsByMethod
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  Template?: React.ComponentType<React.ComponentProps<typeof Template>>
+}
+
+export function Operations({
+  operationsByMethod,
+  Template = defaultTemplates.default,
+}: Props): ReactNode {
+  const { key: pluginKey } = usePlugin<PluginOptions>()
+  const pluginManager = usePluginManager()
+
+  const handlers = getHandlers(operationsByMethod, { resolveName: pluginManager.resolveName, pluginKey })
+
+  return (
+    <Template
+      name="handlers"
+      handlers={handlers.map(item => item.name)}
+    />
+  )
+}
+
+type FileProps = {
+  /**
+   * @deprecated
+   */
+  operationsByMethod: OperationsByMethod
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  templates?: Templates
+}
+
+Operations.File = function(props: FileProps): KubbNode {
+  const templates = { ...defaultTemplates, ...props.templates }
+
+  const Template = templates.default
+  const EditorTemplate = templates.editor
+
+  return (
+    <EditorTemplate operationsByMethod={props.operationsByMethod}>
+      <Operations Template={Template} operationsByMethod={props.operationsByMethod} />
+    </EditorTemplate>
+  )
+}
+
+Operations.templates = defaultTemplates
diff --git a/packages/swagger-msw/src/components/index.ts b/packages/swagger-msw/src/components/index.ts
index f43dc2d36..52858ce75 100644
--- a/packages/swagger-msw/src/components/index.ts
+++ b/packages/swagger-msw/src/components/index.ts
@@ -1,2 +1,2 @@
-export { Handlers } from './Handlers.tsx'
 export { Mock } from './Mock.tsx'
+export { Operations } from './Operations.tsx'
diff --git a/packages/swagger-msw/src/components/utils.ts b/packages/swagger-msw/src/components/utils.ts
new file mode 100644
index 000000000..61528c681
--- /dev/null
+++ b/packages/swagger-msw/src/components/utils.ts
@@ -0,0 +1,46 @@
+import type { KubbFile, ResolveNameParams, ResolvePathParams } from '@kubb/core'
+import type { OperationsByMethod } from '@kubb/swagger'
+import type { Operation } from '@kubb/swagger/oas'
+
+export function getHandlers(
+  operationsByMethod: OperationsByMethod,
+  { resolveName, pluginKey }: { resolveName: (params: ResolveNameParams) => string; pluginKey: ResolveNameParams['pluginKey'] },
+): Array<{ name: string; operation: Operation }> {
+  const handlers: Array<{ name: string; operation: Operation }> = []
+
+  Object.keys(operationsByMethod).forEach((path) => {
+    const operations = operationsByMethod[path]
+    const filteredOperations = [operations?.get, operations?.post, operations?.patch, operations?.put, operations?.delete].filter(Boolean)
+
+    filteredOperations.forEach(({ operation }) => {
+      const operationId = operation.getOperationId()
+      const name = resolveName({ name: operationId, pluginKey, type: 'function' })
+
+      handlers.push({ name, operation })
+    })
+  })
+
+  return handlers
+}
+
+export function getHandlersImports(
+  operationsByMethod: OperationsByMethod,
+  { resolveName, resolvePath, pluginKey }: {
+    resolveName: (params: ResolveNameParams) => string
+    resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath
+    pluginKey: ResolveNameParams['pluginKey']
+  },
+): Array<{ name: string; path: KubbFile.OptionalPath }> {
+  const handlers = getHandlers(operationsByMethod, { resolveName, pluginKey })
+
+  return handlers.map(({ name, operation }) => {
+    const path = resolvePath({
+      pluginKey,
+      baseName: `${name}.ts`,
+      options: {
+        tag: operation?.getTags()[0]?.name,
+      },
+    })
+    return { name, path }
+  })
+}
diff --git a/packages/swagger-msw/src/plugin.ts b/packages/swagger-msw/src/plugin.ts
index 96eff4251..cacf10819 100644
--- a/packages/swagger-msw/src/plugin.ts
+++ b/packages/swagger-msw/src/plugin.ts
@@ -8,7 +8,7 @@ import { getGroupedByTagFiles } from '@kubb/swagger/utils'
 import { pluginName as swaggerFakerPluginName } from '@kubb/swagger-faker'
 import { pluginName as swaggerTypeScriptPluginName } from '@kubb/swagger-ts'
 
-import { Handlers, Mock } from './components/index.ts'
+import { Mock, Operations } from './components/index.ts'
 import { OperationGenerator } from './OperationGenerator.tsx'
 
 import type { Plugin } from '@kubb/core'
@@ -26,15 +26,15 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
     name: pluginName,
     options: {
       templates: {
-        handlers: Handlers.templates,
+        operations: Operations.templates,
         mock: Mock.templates,
         ...templates,
       },
     },
     pre: [swaggerPluginName, swaggerTypeScriptPluginName, swaggerFakerPluginName],
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
diff --git a/packages/swagger-msw/src/types.ts b/packages/swagger-msw/src/types.ts
index d939879f1..bb628542e 100644
--- a/packages/swagger-msw/src/types.ts
+++ b/packages/swagger-msw/src/types.ts
@@ -1,9 +1,9 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
-import type { Handlers, Mock } from './components/index.ts'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Mock, Operations } from './components/index.ts'
 
 type Templates = {
-  handlers?: typeof Handlers.templates | false
+  operations?: typeof Operations.templates | false
   mock?: typeof Mock.templates | false
 }
 
@@ -82,9 +82,8 @@ export type FileMeta = {
   pluginKey?: Plugin['key']
   tag?: string
 }
-type AppMeta = SwaggerAppMeta
 
-export type PluginOptions = PluginFactoryOptions<'swagger-msw', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger-msw', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-swr/src/OperationGenerator.tsx b/packages/swagger-swr/src/OperationGenerator.tsx
index 8c4907759..89277e039 100644
--- a/packages/swagger-swr/src/OperationGenerator.tsx
+++ b/packages/swagger-swr/src/OperationGenerator.tsx
@@ -1,5 +1,6 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Mutation } from './components/Mutation.tsx'
 import { Query } from './components/Query.tsx'
@@ -15,7 +16,7 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     return null
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
@@ -25,14 +26,18 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     }
 
     root.render(
-      <Query.File templates={{ query: options.templates.query, queryOptions: options.templates.queryOptions }} />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Query.File templates={{ query: options.templates.query, queryOptions: options.templates.queryOptions }} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
@@ -41,18 +46,25 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
       return []
     }
 
-    root.render(<Mutation.File templates={options.templates.mutation} />, { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } })
+    root.render(
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Mutation.File templates={options.templates.mutation} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
+    )
 
     return root.files
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
 }
diff --git a/packages/swagger-swr/src/components/Mutation.test.tsx b/packages/swagger-swr/src/components/Mutation.test.tsx
index e1eb42b40..1dfc625e3 100644
--- a/packages/swagger-swr/src/components/Mutation.test.tsx
+++ b/packages/swagger-swr/src/components/Mutation.test.tsx
@@ -2,6 +2,7 @@ import { mockedPluginManager } from '@kubb/core/mocks'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Mutation } from './Mutation.tsx'
@@ -54,11 +55,16 @@ describe('<Mutation/>', async () => {
 
   test('pets', async () => {
     const operation = oas.operation('/pets', 'post')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Mutation.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Mutation.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
diff --git a/packages/swagger-swr/src/components/Query.test.tsx b/packages/swagger-swr/src/components/Query.test.tsx
index c15bc5aee..8923f79f9 100644
--- a/packages/swagger-swr/src/components/Query.test.tsx
+++ b/packages/swagger-swr/src/components/Query.test.tsx
@@ -2,6 +2,7 @@ import { mockedPluginManager } from '@kubb/core/mocks'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Query } from './Query.tsx'
@@ -56,11 +57,16 @@ describe('<Query/>', async () => {
 
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{petId}', 'get')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Query.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Query.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
diff --git a/packages/swagger-swr/src/plugin.ts b/packages/swagger-swr/src/plugin.ts
index c6c55f63b..813e07b7c 100644
--- a/packages/swagger-swr/src/plugin.ts
+++ b/packages/swagger-swr/src/plugin.ts
@@ -45,9 +45,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       dataReturnType,
     },
     pre: [swaggerPluginName],
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
diff --git a/packages/swagger-swr/src/types.ts b/packages/swagger-swr/src/types.ts
index 8b0baf3e0..7c6e1469f 100644
--- a/packages/swagger-swr/src/types.ts
+++ b/packages/swagger-swr/src/types.ts
@@ -1,5 +1,5 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 import type { Mutation } from './components/Mutation.tsx'
 import type { Query } from './components/Query.tsx'
 import type { QueryOptions } from './components/QueryOptions.tsx'
@@ -107,8 +107,8 @@ export type FileMeta = {
   pluginKey?: Plugin['key']
   tag?: string
 }
-type AppMeta = SwaggerAppMeta
-export type PluginOptions = PluginFactoryOptions<'swagger-swr', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+
+export type PluginOptions = PluginFactoryOptions<'swagger-swr', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-tanstack-query/src/OperationGenerator.tsx b/packages/swagger-tanstack-query/src/OperationGenerator.tsx
index 4a431e2d9..6c2ff2f33 100644
--- a/packages/swagger-tanstack-query/src/OperationGenerator.tsx
+++ b/packages/swagger-tanstack-query/src/OperationGenerator.tsx
@@ -1,23 +1,44 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Mutation } from './components/Mutation.tsx'
+import { Operations } from './components/Operations.tsx'
 import { Query } from './components/Query.tsx'
 import { QueryKey } from './components/QueryKey.tsx'
 import { QueryOptions } from './components/QueryOptions.tsx'
 
-import type { KubbFile } from '@kubb/core'
 import type { AppContextProps } from '@kubb/react'
-import type { OperationMethodResult, OperationSchemas } from '@kubb/swagger'
+import type { OperationMethodResult } from '@kubb/swagger'
 import type { Operation } from '@kubb/swagger/oas'
 import type { FileMeta, PluginOptions } from './types.ts'
 
 export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions, FileMeta> {
-  async all(): Promise<KubbFile.File | null> {
-    return null
+  async all(operations: Operation[]): OperationMethodResult<FileMeta> {
+    const { pluginManager, oas, plugin } = this.context
+
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+
+    const templates = {
+      mutation: Mutation.templates,
+      query: Query.templates,
+      queryOptions: QueryOptions.templates,
+      queryKey: QueryKey.templates,
+      operations: Operations.templates,
+      ...this.options.templates,
+    }
+
+    root.render(
+      <Oas oas={oas} operations={operations} getSchemas={(...props) => this.getSchemas(...props)}>
+        {templates.operations && <Operations.File templates={templates.operations} />}
+      </Oas>,
+      { meta: { pluginManager, plugin } },
+    )
+
+    return root.files
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
@@ -35,14 +56,18 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     }
 
     root.render(
-      <Query.File templates={{ query: templates.query, queryKey: templates.queryKey, queryOptions: templates.queryOptions }} />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Query.File templates={{ query: templates.query, queryKey: templates.queryKey, queryOptions: templates.queryOptions }} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
@@ -59,18 +84,25 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
       return []
     }
 
-    root.render(<Mutation.File templates={templates.mutation} />, { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } })
+    root.render(
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Mutation.File templates={templates.mutation} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
+    )
 
     return root.files
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
 }
diff --git a/packages/swagger-tanstack-query/src/components/Mutation.test.tsx b/packages/swagger-tanstack-query/src/components/Mutation.test.tsx
index 71c076096..82bed77b9 100644
--- a/packages/swagger-tanstack-query/src/components/Mutation.test.tsx
+++ b/packages/swagger-tanstack-query/src/components/Mutation.test.tsx
@@ -2,8 +2,10 @@ import { mockedPluginManager } from '@kubb/core/mocks'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
+import { Mutation } from './Mutation.tsx'
 import { Query } from './Query.tsx'
 import { QueryKey } from './QueryKey.tsx'
 import { QueryOptions } from './QueryOptions.tsx'
@@ -63,11 +65,16 @@ describe('<Mutation/>', async () => {
 
   test('pets', async () => {
     const operation = oas.operation('/pets', 'post')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Query.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Mutation.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
diff --git a/packages/swagger-tanstack-query/src/components/Operations.tsx b/packages/swagger-tanstack-query/src/components/Operations.tsx
new file mode 100644
index 000000000..e430f4a44
--- /dev/null
+++ b/packages/swagger-tanstack-query/src/components/Operations.tsx
@@ -0,0 +1,76 @@
+import { Editor, File, usePlugin } from '@kubb/react'
+import { useFile } from '@kubb/react'
+
+import type { KubbNode } from '@kubb/react'
+import type { ComponentProps, ComponentType } from 'react'
+import type { FileMeta, PluginOptions } from '../types.ts'
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type TemplateProps = {}
+
+// eslint-disable-next-line no-empty-pattern
+function Template({}: TemplateProps): KubbNode {
+  return null
+}
+
+type EditorTemplateProps = {
+  children?: React.ReactNode
+}
+
+function EditorTemplate({ children }: EditorTemplateProps) {
+  const { key: pluginKey } = usePlugin<PluginOptions>()
+  const file = useFile({ name: 'operations', mode: 'directory', extName: '.ts', pluginKey })
+
+  return (
+    <Editor language="typescript">
+      <File<FileMeta>
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+      >
+        <File.Source>
+          {children}
+        </File.Source>
+      </File>
+    </Editor>
+  )
+}
+
+const defaultTemplates = { default: Template, editor: EditorTemplate } as const
+
+type Templates = Partial<typeof defaultTemplates>
+
+type Props = {
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  Template?: ComponentType<ComponentProps<typeof Template>>
+}
+
+export function Operations({
+  Template = defaultTemplates.default,
+}: Props): KubbNode {
+  return <Template />
+}
+
+type FileProps = {
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  templates?: Templates
+}
+
+Operations.File = function(props: FileProps): KubbNode {
+  const templates = { ...defaultTemplates, ...props.templates }
+
+  const Template = templates.default
+  const EditorTemplate = templates.editor
+
+  return (
+    <EditorTemplate>
+      <Operations Template={Template} />
+    </EditorTemplate>
+  )
+}
+
+Operations.templates = defaultTemplates
diff --git a/packages/swagger-tanstack-query/src/components/Query.test.tsx b/packages/swagger-tanstack-query/src/components/Query.test.tsx
index e12e7c2a1..433ca407b 100644
--- a/packages/swagger-tanstack-query/src/components/Query.test.tsx
+++ b/packages/swagger-tanstack-query/src/components/Query.test.tsx
@@ -2,6 +2,7 @@ import { mockedPluginManager } from '@kubb/core/mocks'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Query } from './Query.tsx'
@@ -64,11 +65,16 @@ describe('<Query/>', async () => {
 
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{petId}', 'get')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Query.File />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Query.File />
+          </Oas.Operation>
+        </Oas>
+      )
     }
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
diff --git a/packages/swagger-tanstack-query/src/components/__snapshots__/Mutation/Pets.ts b/packages/swagger-tanstack-query/src/components/__snapshots__/Mutation/Pets.ts
index 7d95c545a..4b92f3730 100644
--- a/packages/swagger-tanstack-query/src/components/__snapshots__/Mutation/Pets.ts
+++ b/packages/swagger-tanstack-query/src/components/__snapshots__/Mutation/Pets.ts
@@ -13,47 +13,29 @@ type CreatePets = {
   }
 }
 
-export const CreatePetsQueryKey = () => [{ url: '/pets' }] as const
-export type CreatePetsQueryKey = ReturnType<typeof CreatePetsQueryKey>
-export function CreatePetsQueryOptions<TData = CreatePets['response'], TQueryData = CreatePets['response']>(
-  options: CreatePets['client']['parameters'] = {},
-): WithRequired<UseBaseQueryOptions<CreatePets['response'], CreatePets['error'], TData, TQueryData>, 'queryKey'> {
-  const queryKey = CreatePetsQueryKey()
-
-  return {
-    queryKey,
-    queryFn: async () => {
-      const res = await client<CreatePets['data'], CreatePets['error']>({
-        method: 'post',
-        url: `/pets`,
-        data,
-        ...options,
-      })
-
-      return res.data
-    },
-  }
-}
 /**
  * @summary Create a pet
  * @link /pets */
 
-export function useCreatePets<TData = CreatePets['response'], TQueryData = CreatePets['response'], TQueryKey extends QueryKey = CreatePetsQueryKey>(
+export function useCreatePets(
   options: {
-    query?: Partial<UseBaseQueryOptions<CreatePets['response'], CreatePets['error'], TData, TQueryData, TQueryKey>>
+    mutation?: UseMutationOptions<CreatePets['response'], CreatePets['error'], CreatePets['request']>
     client?: CreatePets['client']['parameters']
   } = {},
-): UseQueryResult<TData, CreatePets['error']> & { queryKey: TQueryKey } {
-  const { query: queryOptions, client: clientOptions = {} } = options ?? {}
-  const queryKey = queryOptions?.queryKey ?? CreatePetsQueryKey()
-
-  const query = useQuery<CreatePets['data'], CreatePets['error'], TData, any>({
-    ...CreatePetsQueryOptions<TData, TQueryData>(clientOptions),
-    queryKey,
-    ...queryOptions,
-  }) as UseQueryResult<TData, CreatePets['error']> & { queryKey: TQueryKey }
+): UseMutationResult<CreatePets['response'], CreatePets['error'], CreatePets['request']> {
+  const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
 
-  query.queryKey = queryKey as TQueryKey
+  return useMutation<CreatePets['response'], CreatePets['error'], CreatePets['request']>({
+    mutationFn: async (data) => {
+      const res = await client<CreatePets['data'], CreatePets['error'], CreatePets['request']>({
+        method: 'post',
+        url: `/pets`,
+        data,
+        ...clientOptions,
+      })
 
-  return query
+      return res.data
+    },
+    ...mutationOptions,
+  })
 }
diff --git a/packages/swagger-tanstack-query/src/components/index.ts b/packages/swagger-tanstack-query/src/components/index.ts
index 44043fc9a..d67949197 100644
--- a/packages/swagger-tanstack-query/src/components/index.ts
+++ b/packages/swagger-tanstack-query/src/components/index.ts
@@ -1,4 +1,5 @@
 export { Mutation } from './Mutation.tsx'
+export { Operations } from './Operations.tsx'
 export { Query } from './Query.tsx'
 export { QueryKey } from './QueryKey.tsx'
 export { QueryOptions } from './QueryOptions.tsx'
diff --git a/packages/swagger-tanstack-query/src/plugin.ts b/packages/swagger-tanstack-query/src/plugin.ts
index 24ad6852d..1f2d7fc24 100644
--- a/packages/swagger-tanstack-query/src/plugin.ts
+++ b/packages/swagger-tanstack-query/src/plugin.ts
@@ -8,7 +8,7 @@ import { getGroupedByTagFiles } from '@kubb/swagger/utils'
 import { pluginName as swaggerTsPluginName } from '@kubb/swagger-ts'
 import { pluginName as swaggerZodPluginName } from '@kubb/swagger-zod'
 
-import { Mutation, Query, QueryKey, QueryOptions } from './components/index.ts'
+import { Mutation, Operations, Query, QueryKey, QueryOptions } from './components/index.ts'
 import { OperationGenerator } from './OperationGenerator.tsx'
 
 import type { Plugin } from '@kubb/core'
@@ -60,14 +60,15 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
         query: Query.templates,
         queryOptions: QueryOptions.templates,
         queryKey: QueryKey.templates,
+        operations: Operations.templates,
         ...templates,
       },
       parser,
     },
     pre: [swaggerPluginName, swaggerTsPluginName, parser === 'zod' ? swaggerZodPluginName : undefined].filter(Boolean),
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
@@ -126,7 +127,6 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       )
 
       const files = await operationGenerator.build()
-
       await this.addFile(...files)
     },
     async writeFile(source, writePath) {
diff --git a/packages/swagger-tanstack-query/src/types.ts b/packages/swagger-tanstack-query/src/types.ts
index a0aec19bd..8bcd5504d 100644
--- a/packages/swagger-tanstack-query/src/types.ts
+++ b/packages/swagger-tanstack-query/src/types.ts
@@ -1,11 +1,13 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 import type { Mutation } from './components/Mutation.tsx'
+import type { Operations } from './components/Operations.tsx'
 import type { Query as QueryTemplate } from './components/Query.tsx'
 import type { QueryKey } from './components/QueryKey.tsx'
 import type { QueryOptions } from './components/QueryOptions.tsx'
 
 type Templates = {
+  operations?: typeof Operations.templates | false
   mutation?: typeof Mutation.templates | false
   query?: typeof QueryTemplate.templates | false
   queryOptions?: typeof QueryOptions.templates | false
@@ -179,8 +181,8 @@ export type FileMeta = {
   pluginKey?: Plugin['key']
   tag?: string
 }
-type AppMeta = SwaggerAppMeta
-export type PluginOptions = PluginFactoryOptions<'swagger-tanstack-query', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+
+export type PluginOptions = PluginFactoryOptions<'swagger-tanstack-query', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-ts/src/OperationGenerator.test.tsx b/packages/swagger-ts/src/OperationGenerator.test.tsx
index 51eb412b3..e5bf6aa36 100644
--- a/packages/swagger-ts/src/OperationGenerator.test.tsx
+++ b/packages/swagger-ts/src/OperationGenerator.test.tsx
@@ -42,8 +42,8 @@ describe('OperationGenerator', async () => {
     const operation = oas.operation('/pets', 'get')
     const operationShowById = oas.operation('/pets/{petId}', 'get')
 
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
-    const getShowByIdFiles = await og.get(operationShowById, og.getSchemas(operationShowById), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
+    const getShowByIdFiles = await og.get(operationShowById, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -79,7 +79,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pets', 'post')
-    const files = await og.post(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.post(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -111,7 +111,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pet/{petId}', 'delete')
-    const files = await og.delete(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.delete(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -142,7 +142,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pet/{petId}', 'delete')
-    const files = await og.delete(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.delete(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
diff --git a/packages/swagger-ts/src/OperationGenerator.tsx b/packages/swagger-ts/src/OperationGenerator.tsx
index 23e277cd2..85879bd32 100644
--- a/packages/swagger-ts/src/OperationGenerator.tsx
+++ b/packages/swagger-ts/src/OperationGenerator.tsx
@@ -1,63 +1,71 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Mutation } from './components/Mutation.tsx'
-import { Oas } from './components/Oas.tsx'
+import { OasType } from './components/OasType.tsx'
 import { Query } from './components/Query.tsx'
 
 import type { AppContextProps } from '@kubb/react'
-import type { OperationMethodResult, OperationSchemas } from '@kubb/swagger'
+import type { OperationMethodResult } from '@kubb/swagger'
 import type { Operation } from '@kubb/swagger/oas'
 import type { FileMeta, PluginOptions } from './types.ts'
 
 export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
-  async all(): OperationMethodResult<FileMeta> {
+  async all(operations: Operation[]): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
-    if (!plugin.options.oasType) {
-      return null
-    }
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
 
-    const root = createRoot<AppContextProps>({ logger: pluginManager.logger })
     root.render(
-      <Oas.File name="oas" typeName="Oas" />,
-      { meta: { oas, pluginManager, plugin } },
+      <Oas oas={oas} operations={operations} getSchemas={(...props) => this.getSchemas(...props)}>
+        {plugin.options.oasType && <OasType.File name="oas" typeName="Oas" />}
+      </Oas>,
+      { meta: { pluginManager, plugin } },
     )
 
     return root.files
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin, mode = 'directory' } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Query.File mode={mode} />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Query.File mode={mode} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin, mode = 'directory' } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Mutation.File mode={mode} />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Mutation.File mode={mode} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
 }
diff --git a/packages/swagger-ts/src/TypeGenerator.ts b/packages/swagger-ts/src/TypeGenerator.ts
index a049ab288..e1321237e 100644
--- a/packages/swagger-ts/src/TypeGenerator.ts
+++ b/packages/swagger-ts/src/TypeGenerator.ts
@@ -342,7 +342,7 @@ export class TypeGenerator extends Generator<PluginOptions['resolvedOptions'], C
 
     if (schema.properties || schema.additionalProperties) {
       // properties -> literal type
-      return this.#getTypeFromProperties(schema, baseName)
+      return this.#getTypeFromProperties(schema as SchemaObject, baseName)
     }
 
     /**
@@ -380,7 +380,7 @@ export class TypeGenerator extends Generator<PluginOptions['resolvedOptions'], C
               {
                 ...schema,
                 type,
-              },
+              } as SchemaObject,
               baseName,
             ),
             nullable ? factory.createLiteralTypeNode(factory.createNull()) : undefined,
diff --git a/packages/swagger-ts/src/components/Mutation.tsx b/packages/swagger-ts/src/components/Mutation.tsx
index 9b5ba72c1..c663b69bd 100644
--- a/packages/swagger-ts/src/components/Mutation.tsx
+++ b/packages/swagger-ts/src/components/Mutation.tsx
@@ -107,7 +107,7 @@ Mutation.File = function({ mode }: FileProps): ReactNode {
 
   const schemas = useSchemas()
   const pluginManager = usePluginManager()
-  const oas = useOas()
+  const { oas } = useOas()
   const file = useOperationFile()
   const factoryName = useOperationName({ type: 'type' })
   const operation = useOperation()
diff --git a/packages/swagger-ts/src/components/Oas.tsx b/packages/swagger-ts/src/components/OasType.tsx
similarity index 87%
rename from packages/swagger-ts/src/components/Oas.tsx
rename to packages/swagger-ts/src/components/OasType.tsx
index ed86b518e..441a6bbca 100644
--- a/packages/swagger-ts/src/components/Oas.tsx
+++ b/packages/swagger-ts/src/components/OasType.tsx
@@ -42,12 +42,12 @@ type Props = {
   Template?: React.ComponentType<React.ComponentProps<typeof Template>>
 }
 
-export function Oas({
+export function OasType({
   name,
   typeName,
   Template = defaultTemplates.default,
 }: Props): ReactNode {
-  const oas = useOas()
+  const { oas } = useOas()
 
   return <Template name={name} typeName={typeName} api={oas.api} />
 }
@@ -61,7 +61,7 @@ type FileProps = {
   templates?: typeof defaultTemplates
 }
 
-Oas.File = function({ name, typeName, templates = defaultTemplates }: FileProps): ReactNode {
+OasType.File = function({ name, typeName, templates = defaultTemplates }: FileProps): ReactNode {
   const { key: pluginKey } = usePlugin<PluginOptions>()
   const file = useFile({ name, extName: '.ts', pluginKey })
 
@@ -76,11 +76,11 @@ Oas.File = function({ name, typeName, templates = defaultTemplates }: FileProps)
       >
         <File.Import name={['Infer']} path="@kubb/swagger-ts/oas" isTypeOnly />
         <File.Source>
-          <Oas Template={Template} name={name} typeName={typeName} />
+          <OasType Template={Template} name={name} typeName={typeName} />
         </File.Source>
       </File>
     </Editor>
   )
 }
 
-Oas.templates = defaultTemplates
+OasType.templates = defaultTemplates
diff --git a/packages/swagger-ts/src/components/Query.tsx b/packages/swagger-ts/src/components/Query.tsx
index 29cf2e0e5..8d4e6d49b 100644
--- a/packages/swagger-ts/src/components/Query.tsx
+++ b/packages/swagger-ts/src/components/Query.tsx
@@ -108,7 +108,7 @@ Query.File = function({ mode }: FileProps): ReactNode {
 
   const schemas = useSchemas()
   const pluginManager = usePluginManager()
-  const oas = useOas()
+  const { oas } = useOas()
   const file = useOperationFile()
   const factoryName = useOperationName({ type: 'type' })
   const operation = useOperation()
diff --git a/packages/swagger-ts/src/components/index.ts b/packages/swagger-ts/src/components/index.ts
index e57865746..3e14706cd 100644
--- a/packages/swagger-ts/src/components/index.ts
+++ b/packages/swagger-ts/src/components/index.ts
@@ -1,3 +1,3 @@
 export { Mutation } from './Mutation.tsx'
-export { Oas } from './Oas.tsx'
+export { OasType } from './OasType.tsx'
 export { Query } from './Query.tsx'
diff --git a/packages/swagger-ts/src/plugin.ts b/packages/swagger-ts/src/plugin.ts
index dace6ed30..ca7910c1b 100644
--- a/packages/swagger-ts/src/plugin.ts
+++ b/packages/swagger-ts/src/plugin.ts
@@ -46,9 +46,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       unknownType,
     },
     pre: [swaggerPluginName],
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
diff --git a/packages/swagger-ts/src/types.ts b/packages/swagger-ts/src/types.ts
index daddf1e77..fa77757c0 100644
--- a/packages/swagger-ts/src/types.ts
+++ b/packages/swagger-ts/src/types.ts
@@ -1,5 +1,5 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 
 export type Options = {
   output?: {
@@ -111,9 +111,7 @@ export type FileMeta = {
   tag?: string
 }
 
-type AppMeta = SwaggerAppMeta
-
-export type PluginOptions = PluginFactoryOptions<'swagger-ts', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger-ts', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-zod/src/OperationGenerator.test.tsx b/packages/swagger-zod/src/OperationGenerator.test.tsx
index 5593d0e51..8a87d9841 100644
--- a/packages/swagger-zod/src/OperationGenerator.test.tsx
+++ b/packages/swagger-zod/src/OperationGenerator.test.tsx
@@ -41,8 +41,8 @@ describe('OperationGenerator', async () => {
     const operation = oas.operation('/pets', 'get')
     const operationShowById = oas.operation('/pets/{petId}', 'get')
 
-    const files = await og.get(operation, og.getSchemas(operation), options) as KubbFile.File[]
-    const getShowByIdFiles = await og.get(operationShowById, og.getSchemas(operationShowById), options) as KubbFile.File[]
+    const files = await og.get(operation, options) as KubbFile.File[]
+    const getShowByIdFiles = await og.get(operationShowById, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -77,7 +77,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pets', 'post')
-    const files = await og.post(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.post(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -108,7 +108,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pet/{petId}', 'delete')
-    const files = await og.delete(operation, og.getSchemas(operation), options) as KubbFile.File[]
+    const files = await og.delete(operation, options) as KubbFile.File[]
 
     files.forEach(file => {
       expect(FileManager.getSource(file)).toMatchSnapshot()
@@ -139,7 +139,7 @@ describe('OperationGenerator', async () => {
       },
     )
     const operation = oas.operation('/pet/{petId}', 'delete')
-    const files = await og.delete(operation, og.getSchemas(operation), options)
+    const files = await og.delete(operation, options)
 
     expect(files).toMatchSnapshot()
   })
diff --git a/packages/swagger-zod/src/OperationGenerator.tsx b/packages/swagger-zod/src/OperationGenerator.tsx
index 0454d1481..ad89ce51a 100644
--- a/packages/swagger-zod/src/OperationGenerator.tsx
+++ b/packages/swagger-zod/src/OperationGenerator.tsx
@@ -1,5 +1,6 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Mutation } from './components/Mutation.tsx'
 import { Query } from './components/Query.tsx'
@@ -15,37 +16,45 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     return null
   }
 
-  async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin, mode } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Query.File mode={mode} />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Query.File mode={mode} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async post(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin, mode } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Mutation.File mode={mode} />,
-      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } },
+      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Oas.Operation operation={operation}>
+          <Mutation.File mode={mode} />
+        </Oas.Operation>
+      </Oas>,
+      { meta: { pluginManager, plugin: { ...plugin, options } } },
     )
 
     return root.files
   }
 
-  async put(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async patch(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
-  async delete(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, schemas, options)
+  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
+    return this.post(operation, options)
   }
 }
diff --git a/packages/swagger-zod/src/components/Mutation.test.tsx b/packages/swagger-zod/src/components/Mutation.test.tsx
index 6449f6bb0..8b760b183 100644
--- a/packages/swagger-zod/src/components/Mutation.test.tsx
+++ b/packages/swagger-zod/src/components/Mutation.test.tsx
@@ -1,6 +1,7 @@
 import { mockedPluginManager } from '@kubb/core/mocks'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Mutation } from './Mutation.tsx'
@@ -43,12 +44,18 @@ describe('<Mutation/>', async () => {
 
   test('pets', async () => {
     const operation = oas.operation('/pets', 'post')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Mutation.File mode="directory" />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Mutation.File mode="directory" />
+          </Oas.Operation>
+        </Oas>
+      )
     }
+
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
 
diff --git a/packages/swagger-zod/src/components/Mutation.tsx b/packages/swagger-zod/src/components/Mutation.tsx
index 82f41071d..bc51f8792 100644
--- a/packages/swagger-zod/src/components/Mutation.tsx
+++ b/packages/swagger-zod/src/components/Mutation.tsx
@@ -32,7 +32,7 @@ Mutation.File = function({ mode = 'directory' }: FileProps): ReactNode {
 
   const schemas = useSchemas()
   const pluginManager = usePluginManager()
-  const oas = useOas()
+  const { oas } = useOas()
   const file = useOperationFile()
 
   const builder = new ZodBuilder(options, { oas, pluginManager })
diff --git a/packages/swagger-zod/src/components/Query.test.tsx b/packages/swagger-zod/src/components/Query.test.tsx
index 77e002eb1..aad154b0a 100644
--- a/packages/swagger-zod/src/components/Query.test.tsx
+++ b/packages/swagger-zod/src/components/Query.test.tsx
@@ -1,6 +1,7 @@
 import { mockedPluginManager } from '@kubb/core/mocks'
 import { createRootServer } from '@kubb/react/server'
 import { OasManager } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { OperationGenerator } from '../OperationGenerator.tsx'
 import { Query } from './Query.tsx'
@@ -43,12 +44,18 @@ describe('<Query/>', async () => {
 
   test('showPetById', async () => {
     const operation = oas.operation('/pets/{petId}', 'get')
-    const schemas = og.getSchemas(operation)
-    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { oas, pluginManager: mockedPluginManager, plugin, schemas, operation } }
+    const context: AppContextProps<PluginOptions['appMeta']> = { meta: { pluginManager: mockedPluginManager, plugin } }
 
     const Component = () => {
-      return <Query.File mode="directory" />
+      return (
+        <Oas oas={oas} operations={[operation]} getSchemas={(...props) => og.getSchemas(...props)}>
+          <Oas.Operation operation={operation}>
+            <Query.File mode="directory" />
+          </Oas.Operation>
+        </Oas>
+      )
     }
+
     const root = createRootServer({ logger: mockedPluginManager.logger })
     const output = await root.renderToString(<Component />, context)
 
diff --git a/packages/swagger-zod/src/components/Query.tsx b/packages/swagger-zod/src/components/Query.tsx
index 7211e627b..65aa92a3a 100644
--- a/packages/swagger-zod/src/components/Query.tsx
+++ b/packages/swagger-zod/src/components/Query.tsx
@@ -32,7 +32,7 @@ Query.File = function({ mode = 'directory' }: FileProps): ReactNode {
 
   const schemas = useSchemas()
   const pluginManager = usePluginManager()
-  const oas = useOas()
+  const { oas } = useOas()
   const file = useOperationFile()
 
   const builder = new ZodBuilder(options, { oas, pluginManager })
diff --git a/packages/swagger-zod/src/plugin.ts b/packages/swagger-zod/src/plugin.ts
index e15d589b5..0228ea4ad 100644
--- a/packages/swagger-zod/src/plugin.ts
+++ b/packages/swagger-zod/src/plugin.ts
@@ -35,9 +35,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       unknownType,
     },
     pre: [swaggerPluginName, typed ? swaggerTypeScriptPluginName : undefined].filter(Boolean),
-    resolvePath(baseName, directory, options) {
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
diff --git a/packages/swagger-zod/src/types.ts b/packages/swagger-zod/src/types.ts
index cc6c7c794..795baf036 100644
--- a/packages/swagger-zod/src/types.ts
+++ b/packages/swagger-zod/src/types.ts
@@ -1,5 +1,5 @@
 import type { KubbFile, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 
 export type Options = {
   output?: {
@@ -93,9 +93,8 @@ export type FileMeta = {
   pluginKey?: Plugin['key']
   tag?: string
 }
-type AppMeta = SwaggerAppMeta
 
-export type PluginOptions = PluginFactoryOptions<'swagger-zod', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger-zod', Options, ResolvedOptions, never, ResolvePathOptions>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger-zodios/src/OperationGenerator.tsx b/packages/swagger-zodios/src/OperationGenerator.tsx
index c5fd43b18..bd9431e86 100644
--- a/packages/swagger-zodios/src/OperationGenerator.tsx
+++ b/packages/swagger-zodios/src/OperationGenerator.tsx
@@ -1,21 +1,28 @@
 import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
+import { Oas } from '@kubb/swagger/components'
 
 import { Definitions } from './components/Definitions.tsx'
 
 import type { AppContextProps } from '@kubb/react'
-import type { OperationMethodResult, Paths } from '@kubb/swagger'
+import type { OperationMethodResult, OperationsByMethod } from '@kubb/swagger'
+import type { Operation } from '@kubb/swagger/oas'
 import type { FileMeta, PluginOptions } from './types.ts'
 
 export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
-  async all(paths: Paths): OperationMethodResult<FileMeta> {
+  async all(operations: Operation[], operationsByMethod: OperationsByMethod): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
-    const root = createRoot<AppContextProps>({ logger: pluginManager.logger })
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
 
-    root.render(<Definitions.File name={this.options.name} baseURL={this.options.baseURL} paths={paths} />, {
-      meta: { oas, pluginManager, plugin },
-    })
+    root.render(
+      <Oas oas={oas} operations={operations} getSchemas={(...props) => this.getSchemas(...props)}>
+        <Definitions.File name={this.options.name} baseURL={this.options.baseURL} operationsByMethod={operationsByMethod} />
+      </Oas>,
+      {
+        meta: { pluginManager, plugin },
+      },
+    )
 
     return root.files
   }
diff --git a/packages/swagger-zodios/src/components/Definitions.tsx b/packages/swagger-zodios/src/components/Definitions.tsx
index 36aaf0bea..4cd1a016b 100644
--- a/packages/swagger-zodios/src/components/Definitions.tsx
+++ b/packages/swagger-zodios/src/components/Definitions.tsx
@@ -4,10 +4,9 @@ import { Editor, File, useFile, usePlugin } from '@kubb/react'
 import { usePluginManager } from '@kubb/react'
 import { pluginKey as swaggerZodPluginKey } from '@kubb/swagger-zod'
 
-import type { ResolveNameParams, ResolvePathParams } from '@kubb/core'
-import type { KubbFile } from '@kubb/core'
-import type { OperationSchemas, Paths } from '@kubb/swagger'
-import type { OasTypes, Operation } from '@kubb/swagger/oas'
+import { getDefinitions, getDefinitionsImports } from './utils.ts'
+
+import type { OperationsByMethod } from '@kubb/swagger'
 import type { ReactNode } from 'react'
 import type { FileMeta, PluginOptions } from '../types.ts'
 
@@ -40,226 +39,9 @@ function Template({
 }
 const defaultTemplates = { default: Template } as const
 
-const parameters = {
-  getPathParams(name: string, item: NonNullable<OperationSchemas['pathParams']>): string[] {
-    const parameters: string[] = []
-
-    item.keys?.forEach((key) => {
-      const schema = item.schema?.properties?.[key] as OasTypes.SchemaObject
-      const shape = item.schema?.$ref ? `schema.shape['${key}']` : `shape['${key}']`
-      const required = Array.isArray(item.schema.required) ? !!item.schema.required?.length : !!item.schema.required
-      const definedSchema = required ? `${name}.${shape}` : `${name}.unwrap().${shape}`
-
-      parameters.push(`
-        {
-          name: "${key}",
-          description: \`${transformers.escape(schema?.description)}\`,
-          type: "Path",
-          schema: ${definedSchema}
-        }
-      `)
-    })
-
-    return parameters
-  },
-  getQueryParams(name: string, item: NonNullable<OperationSchemas['queryParams']>): string[] {
-    const parameters: string[] = []
-
-    item.keys?.forEach((key) => {
-      const schema = item.schema?.properties?.[key] as OasTypes.SchemaObject
-      const shape = item.schema?.$ref ? `schema.shape['${key}']` : `shape['${key}']`
-      const required = Array.isArray(item.schema.required) ? !!item.schema.required?.length : !!item.schema.required
-      const definedSchema = required ? `${name}.${shape}` : `${name}.unwrap().${shape}`
-
-      parameters.push(`
-      {
-        name: "${key}",
-        description: \`${transformers.escape(schema?.description)}\`,
-        type: "Query",
-        schema: ${definedSchema}
-      }
-    `)
-    })
-    return parameters
-  },
-  getHeaderParams(name: string, item: NonNullable<OperationSchemas['queryParams']>): string[] {
-    const parameters: string[] = []
-
-    item.keys?.forEach((key) => {
-      const schema = item.schema?.properties?.[key] as OasTypes.SchemaObject
-      const shape = item.schema?.$ref ? `schema.shape['${key}']` : `shape['${key}']`
-      const required = Array.isArray(item.schema.required) ? !!item.schema.required?.length : !!item.schema.required
-      const definedSchema = required ? `${name}.${shape}` : `${name}.unwrap().${shape}`
-
-      parameters.push(`
-      {
-        name: "${key}",
-        description: \`${transformers.escape(schema?.description)}\`,
-        type: "Header",
-        schema: ${definedSchema}
-      }
-    `)
-    })
-    return parameters
-  },
-  getRequest(name: string, item: NonNullable<OperationSchemas['request']>): string[] {
-    const parameters: string[] = []
-
-    parameters.push(`
-    {
-      name: "${item.name}",
-      description: \`${transformers.escape(item.description)}\`,
-      type: "Body",
-      schema: ${name}
-    }
-  `)
-    return parameters
-  },
-} as const
-
-function getDefinitionsImports(
-  paths: Paths,
-  { resolveName, resolvePath, pluginKey }: {
-    resolveName: (params: ResolveNameParams) => string
-    resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath
-    pluginKey: ResolveNameParams['pluginKey']
-  },
-): Array<{ name: string; path: KubbFile.OptionalPath }> {
-  const definitions: Array<{ name: string; operation: Operation }> = []
-
-  Object.keys(paths).forEach((path) => {
-    const operations = paths[path]
-    const filteredOperations = [operations?.get, operations?.post, operations?.patch, operations?.put, operations?.delete].filter(Boolean)
-
-    filteredOperations.forEach(({ operation, schemas }) => {
-      const responseName = resolveName({ name: schemas.response.name, pluginKey, type: 'function' })
-
-      definitions.push({ name: responseName, operation })
-
-      if (schemas.pathParams?.name) {
-        const name = resolveName({ name: schemas.pathParams.name, pluginKey, type: 'function' })
-
-        definitions.push({ name, operation })
-      }
-
-      if (schemas.queryParams?.name) {
-        const name = resolveName({ name: schemas.queryParams.name, pluginKey, type: 'function' })
-
-        definitions.push({ name, operation })
-      }
-
-      if (schemas.headerParams?.name) {
-        const name = resolveName({ name: schemas.headerParams.name, pluginKey, type: 'function' })
-
-        definitions.push({ name, operation })
-      }
-
-      if (schemas.request?.name) {
-        const name = resolveName({ name: schemas.request.name, pluginKey, type: 'function' })
-
-        definitions.push({ name, operation })
-      }
-      if (schemas.errors) {
-        schemas.errors.forEach(
-          (errorOperationSchema) => {
-            if (!errorOperationSchema.statusCode) {
-              return
-            }
-
-            const name = resolveName({ name: `${operation.getOperationId()} ${errorOperationSchema.statusCode}`, pluginKey, type: 'function' })
-
-            definitions.push({ name, operation })
-          },
-        )
-      }
-    })
-  })
-
-  return definitions.map(({ name, operation }) => {
-    const baseName = resolveName({ name: `${operation.getOperationId()}`, pluginKey, type: 'file' })
-
-    const path = resolvePath({
-      pluginKey,
-      baseName: `${baseName}.ts`,
-      options: {
-        tag: operation?.getTags()[0]?.name,
-      },
-    })
-    return { name, path }
-  })
-}
-
-function getDefinitions(
-  paths: Paths,
-  { resolveName, pluginKey }: { resolveName: (params: ResolveNameParams) => string; pluginKey: ResolveNameParams['pluginKey'] },
-): Array<{ operation: Operation; response: string | undefined; parameters: string[]; errors: string[] }> {
-  const definitions: Array<{ response: string; operation: Operation; parameters: string[]; errors: string[] }> = []
-
-  Object.keys(paths).forEach((path) => {
-    const operations = paths[path]
-    const filteredOperations = [operations?.get, operations?.post, operations?.patch, operations?.put, operations?.delete].filter(Boolean)
-
-    filteredOperations.forEach(({ operation, schemas }) => {
-      let params: string[] = []
-      const errors: string[] = []
-      const responseName = resolveName({ name: schemas.response.name, pluginKey, type: 'function' })
-
-      // definitions.push({ name: responseName, response: responseName, operation, parameters: [], errors: [] })
-
-      if (schemas.pathParams?.name) {
-        const name = resolveName({ name: schemas.pathParams.name, pluginKey, type: 'function' })
-        params = [...params, ...parameters.getPathParams(name, schemas.pathParams)]
-        // definitions.push({ name, response: undefined, operation, parameters: parameters.getPathParams(name, schemas.pathParams), errors: [] })
-      }
-
-      if (schemas.queryParams?.name) {
-        const name = resolveName({ name: schemas.queryParams.name, pluginKey, type: 'function' })
-        params = [...params, ...parameters.getQueryParams(name, schemas.queryParams)]
-        // definitions.push({ name, operation, parameters: parameters.getQueryParams(name, schemas.queryParams), errors: [] })
-      }
-
-      if (schemas.headerParams?.name) {
-        const name = resolveName({ name: schemas.headerParams.name, pluginKey, type: 'function' })
-        params = [...params, ...parameters.getHeaderParams(name, schemas.headerParams)]
-        // definitions.push({ name, operation, parameters: parameters.getHeaderParams(name, schemas.headerParams), errors: [] })
-      }
-
-      if (schemas.request?.name) {
-        const name = resolveName({ name: schemas.request.name, pluginKey, type: 'function' })
-        params = [...params, ...parameters.getRequest(name, schemas.request)]
-        // definitions.push({ name, operation, parameters: parameters.getRequest(name, schemas.request), errors: [] })
-      }
-      if (schemas.errors) {
-        schemas.errors.forEach(
-          (errorOperationSchema) => {
-            if (!errorOperationSchema.statusCode) {
-              return
-            }
-
-            const name = resolveName({ name: `${operation.getOperationId()} ${errorOperationSchema.statusCode}`, pluginKey, type: 'function' })
-
-            if (errorOperationSchema.statusCode) {
-              errors.push(`
-              {
-                status: ${errorOperationSchema.statusCode},
-                description: \`${transformers.escape(errorOperationSchema.description)}\`,
-                schema: ${name}
-              }
-            `)
-            }
-          },
-        )
-      }
-      definitions.push({ operation, parameters: params, errors, response: responseName })
-    })
-  })
-
-  return definitions
-}
-
 type Props = {
   baseURL: string | undefined
-  paths: Paths
+  operationsByMethod: OperationsByMethod
   /**
    * This will make it possible to override the default behaviour.
    */
@@ -268,11 +50,11 @@ type Props = {
 
 export function Definitions({
   baseURL,
-  paths,
+  operationsByMethod,
   Template = defaultTemplates.default,
 }: Props): ReactNode {
   const pluginManager = usePluginManager()
-  const definitions = getDefinitions(paths, { resolveName: pluginManager.resolveName, pluginKey: swaggerZodPluginKey })
+  const definitions = getDefinitions(operationsByMethod, { resolveName: pluginManager.resolveName, pluginKey: swaggerZodPluginKey })
 
   return (
     <Template
@@ -302,19 +84,22 @@ export function Definitions({
 type FileProps = {
   name: string
   baseURL: string | undefined
-  paths: Paths
+  /**
+   * @deprecated
+   */
+  operationsByMethod: OperationsByMethod
   /**
    * This will make it possible to override the default behaviour.
    */
   templates?: typeof defaultTemplates
 }
 
-Definitions.File = function({ name, baseURL, paths, templates = defaultTemplates }: FileProps): ReactNode {
+Definitions.File = function({ name, baseURL, operationsByMethod, templates = defaultTemplates }: FileProps): ReactNode {
   const pluginManager = usePluginManager()
   const { key: pluginKey } = usePlugin<PluginOptions>()
   const file = useFile({ name, extName: '.ts', pluginKey })
 
-  const definitionsImports = getDefinitionsImports(paths, {
+  const definitionsImports = getDefinitionsImports(operationsByMethod, {
     resolveName: pluginManager.resolveName,
     resolvePath: pluginManager.resolvePath,
     pluginKey: swaggerZodPluginKey,
@@ -340,7 +125,7 @@ Definitions.File = function({ name, baseURL, paths, templates = defaultTemplates
         <File.Import name={['makeApi', 'Zodios']} path="@zodios/core" />
         {imports}
         <File.Source>
-          <Definitions Template={Template} paths={paths} baseURL={baseURL} />
+          <Definitions Template={Template} operationsByMethod={operationsByMethod} baseURL={baseURL} />
         </File.Source>
       </File>
     </Editor>
diff --git a/packages/swagger-zodios/src/components/utils.ts b/packages/swagger-zodios/src/components/utils.ts
new file mode 100644
index 000000000..ee7129f9f
--- /dev/null
+++ b/packages/swagger-zodios/src/components/utils.ts
@@ -0,0 +1,223 @@
+import transformers from '@kubb/core/transformers'
+
+import type { ResolveNameParams, ResolvePathParams } from '@kubb/core'
+import type { KubbFile } from '@kubb/core'
+import type { OperationsByMethod, OperationSchemas } from '@kubb/swagger'
+import type { OasTypes, Operation } from '@kubb/swagger/oas'
+
+const parameters = {
+  getPathParams(name: string, item: NonNullable<OperationSchemas['pathParams']>): string[] {
+    const parameters: string[] = []
+
+    item.keys?.forEach((key) => {
+      const schema = item.schema?.properties?.[key] as OasTypes.SchemaObject
+      const shape = item.schema?.$ref ? `schema.shape['${key}']` : `shape['${key}']`
+      const required = Array.isArray(item.schema.required) ? !!item.schema.required?.length : !!item.schema.required
+      const definedSchema = required ? `${name}.${shape}` : `${name}.unwrap().${shape}`
+
+      parameters.push(`
+        {
+          name: "${key}",
+          description: \`${transformers.escape(schema?.description)}\`,
+          type: "Path",
+          schema: ${definedSchema}
+        }
+      `)
+    })
+
+    return parameters
+  },
+  getQueryParams(name: string, item: NonNullable<OperationSchemas['queryParams']>): string[] {
+    const parameters: string[] = []
+
+    item.keys?.forEach((key) => {
+      const schema = item.schema?.properties?.[key] as OasTypes.SchemaObject
+      const shape = item.schema?.$ref ? `schema.shape['${key}']` : `shape['${key}']`
+      const required = Array.isArray(item.schema.required) ? !!item.schema.required?.length : !!item.schema.required
+      const definedSchema = required ? `${name}.${shape}` : `${name}.unwrap().${shape}`
+
+      parameters.push(`
+      {
+        name: "${key}",
+        description: \`${transformers.escape(schema?.description)}\`,
+        type: "Query",
+        schema: ${definedSchema}
+      }
+    `)
+    })
+    return parameters
+  },
+  getHeaderParams(name: string, item: NonNullable<OperationSchemas['queryParams']>): string[] {
+    const parameters: string[] = []
+
+    item.keys?.forEach((key) => {
+      const schema = item.schema?.properties?.[key] as OasTypes.SchemaObject
+      const shape = item.schema?.$ref ? `schema.shape['${key}']` : `shape['${key}']`
+      const required = Array.isArray(item.schema.required) ? !!item.schema.required?.length : !!item.schema.required
+      const definedSchema = required ? `${name}.${shape}` : `${name}.unwrap().${shape}`
+
+      parameters.push(`
+      {
+        name: "${key}",
+        description: \`${transformers.escape(schema?.description)}\`,
+        type: "Header",
+        schema: ${definedSchema}
+      }
+    `)
+    })
+    return parameters
+  },
+  getRequest(name: string, item: NonNullable<OperationSchemas['request']>): string[] {
+    const parameters: string[] = []
+
+    parameters.push(`
+    {
+      name: "${item.name}",
+      description: \`${transformers.escape(item.description)}\`,
+      type: "Body",
+      schema: ${name}
+    }
+  `)
+    return parameters
+  },
+} as const
+
+export function getDefinitionsImports(
+  operationsByMethod: OperationsByMethod,
+  { resolveName, resolvePath, pluginKey }: {
+    resolveName: (params: ResolveNameParams) => string
+    resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath
+    pluginKey: ResolveNameParams['pluginKey']
+  },
+): Array<{ name: string; path: KubbFile.OptionalPath }> {
+  const definitions: Array<{ name: string; operation: Operation }> = []
+
+  Object.keys(operationsByMethod).forEach((path) => {
+    const operations = operationsByMethod[path]
+    const filteredOperations = [operations?.get, operations?.post, operations?.patch, operations?.put, operations?.delete].filter(Boolean)
+
+    filteredOperations.forEach(({ operation, schemas }) => {
+      const responseName = resolveName({ name: schemas.response.name, pluginKey, type: 'function' })
+
+      definitions.push({ name: responseName, operation })
+
+      if (schemas.pathParams?.name) {
+        const name = resolveName({ name: schemas.pathParams.name, pluginKey, type: 'function' })
+
+        definitions.push({ name, operation })
+      }
+
+      if (schemas.queryParams?.name) {
+        const name = resolveName({ name: schemas.queryParams.name, pluginKey, type: 'function' })
+
+        definitions.push({ name, operation })
+      }
+
+      if (schemas.headerParams?.name) {
+        const name = resolveName({ name: schemas.headerParams.name, pluginKey, type: 'function' })
+
+        definitions.push({ name, operation })
+      }
+
+      if (schemas.request?.name) {
+        const name = resolveName({ name: schemas.request.name, pluginKey, type: 'function' })
+
+        definitions.push({ name, operation })
+      }
+      if (schemas.errors) {
+        schemas.errors.forEach(
+          (errorOperationSchema) => {
+            if (!errorOperationSchema.statusCode) {
+              return
+            }
+
+            const name = resolveName({ name: `${operation.getOperationId()} ${errorOperationSchema.statusCode}`, pluginKey, type: 'function' })
+
+            definitions.push({ name, operation })
+          },
+        )
+      }
+    })
+  })
+
+  return definitions.map(({ name, operation }) => {
+    const baseName = resolveName({ name: `${operation.getOperationId()}`, pluginKey, type: 'file' })
+
+    const path = resolvePath({
+      pluginKey,
+      baseName: `${baseName}.ts`,
+      options: {
+        tag: operation?.getTags()[0]?.name,
+      },
+    })
+    return { name, path }
+  })
+}
+
+export function getDefinitions(
+  operationsByMethod: OperationsByMethod,
+  { resolveName, pluginKey }: { resolveName: (params: ResolveNameParams) => string; pluginKey: ResolveNameParams['pluginKey'] },
+): Array<{ operation: Operation; response: string | undefined; parameters: string[]; errors: string[] }> {
+  const definitions: Array<{ response: string; operation: Operation; parameters: string[]; errors: string[] }> = []
+
+  Object.keys(operationsByMethod).forEach((path) => {
+    const operations = operationsByMethod[path]
+    const filteredOperations = [operations?.get, operations?.post, operations?.patch, operations?.put, operations?.delete].filter(Boolean)
+
+    filteredOperations.forEach(({ operation, schemas }) => {
+      let params: string[] = []
+      const errors: string[] = []
+      const responseName = resolveName({ name: schemas.response.name, pluginKey, type: 'function' })
+
+      // definitions.push({ name: responseName, response: responseName, operation, parameters: [], errors: [] })
+
+      if (schemas.pathParams?.name) {
+        const name = resolveName({ name: schemas.pathParams.name, pluginKey, type: 'function' })
+        params = [...params, ...parameters.getPathParams(name, schemas.pathParams)]
+        // definitions.push({ name, response: undefined, operation, parameters: parameters.getPathParams(name, schemas.pathParams), errors: [] })
+      }
+
+      if (schemas.queryParams?.name) {
+        const name = resolveName({ name: schemas.queryParams.name, pluginKey, type: 'function' })
+        params = [...params, ...parameters.getQueryParams(name, schemas.queryParams)]
+        // definitions.push({ name, operation, parameters: parameters.getQueryParams(name, schemas.queryParams), errors: [] })
+      }
+
+      if (schemas.headerParams?.name) {
+        const name = resolveName({ name: schemas.headerParams.name, pluginKey, type: 'function' })
+        params = [...params, ...parameters.getHeaderParams(name, schemas.headerParams)]
+        // definitions.push({ name, operation, parameters: parameters.getHeaderParams(name, schemas.headerParams), errors: [] })
+      }
+
+      if (schemas.request?.name) {
+        const name = resolveName({ name: schemas.request.name, pluginKey, type: 'function' })
+        params = [...params, ...parameters.getRequest(name, schemas.request)]
+        // definitions.push({ name, operation, parameters: parameters.getRequest(name, schemas.request), errors: [] })
+      }
+      if (schemas.errors) {
+        schemas.errors.forEach(
+          (errorOperationSchema) => {
+            if (!errorOperationSchema.statusCode) {
+              return
+            }
+
+            const name = resolveName({ name: `${operation.getOperationId()} ${errorOperationSchema.statusCode}`, pluginKey, type: 'function' })
+
+            if (errorOperationSchema.statusCode) {
+              errors.push(`
+              {
+                status: ${errorOperationSchema.statusCode},
+                description: \`${transformers.escape(errorOperationSchema.description)}\`,
+                schema: ${name}
+              }
+            `)
+            }
+          },
+        )
+      }
+      definitions.push({ operation, parameters: params, errors, response: responseName })
+    })
+  })
+
+  return definitions
+}
diff --git a/packages/swagger-zodios/src/plugin.ts b/packages/swagger-zodios/src/plugin.ts
index a8f7c6e8d..36d3249ad 100644
--- a/packages/swagger-zodios/src/plugin.ts
+++ b/packages/swagger-zodios/src/plugin.ts
@@ -25,7 +25,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       baseURL: undefined,
     },
     pre: [swaggerPluginName, swaggerZodPluginName],
-    resolvePath(baseName, _directory) {
+    resolvePath(baseName) {
       const root = path.resolve(this.config.root, this.config.output.path)
 
       return path.resolve(root, baseName)
diff --git a/packages/swagger-zodios/src/types.ts b/packages/swagger-zodios/src/types.ts
index 4b2cb126d..19b4d4782 100644
--- a/packages/swagger-zodios/src/types.ts
+++ b/packages/swagger-zodios/src/types.ts
@@ -1,5 +1,4 @@
 import type { KubbFile, Plugin, PluginFactoryOptions } from '@kubb/core'
-import type { AppMeta as SwaggerAppMeta } from '@kubb/swagger'
 
 export type Options = {
   output?: {
@@ -35,9 +34,7 @@ export type FileMeta = {
   tag?: string
 }
 
-type AppMeta = SwaggerAppMeta
-
-export type PluginOptions = PluginFactoryOptions<'swagger-zodios', Options, ResolveOptions, never, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger-zodios', Options, ResolveOptions, never>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger/package.json b/packages/swagger/package.json
index 385e221ca..793001637 100644
--- a/packages/swagger/package.json
+++ b/packages/swagger/package.json
@@ -35,6 +35,11 @@
       "require": "./dist/hooks.cjs",
       "default": "./dist/hooks.cjs"
     },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
     "./oas": {
       "import": "./dist/oas.js",
       "require": "./dist/oas.cjs",
@@ -56,6 +61,9 @@
       ],
       "oas": [
         "./dist/oas.d.ts"
+      ],
+      "components": [
+        "./dist/components.d.ts"
       ]
     }
   },
@@ -91,9 +99,10 @@
     "@kubb/ts-config": "workspace:*",
     "@kubb/tsup-config": "workspace:*",
     "@types/js-yaml": "^4.0.9",
-    "@types/react": "^18.2.64",
     "@types/swagger2openapi": "^7.0.4",
+    "@types/react": "^18.2.64",
     "eslint": "^8.57.0",
+    "react": "^18.2.0",
     "tsup": "^8.0.2",
     "typescript": "^5.4.2"
   },
diff --git a/packages/swagger/src/OperationGenerator.ts b/packages/swagger/src/OperationGenerator.ts
index 4a51987de..74b8b1766 100644
--- a/packages/swagger/src/OperationGenerator.ts
+++ b/packages/swagger/src/OperationGenerator.ts
@@ -10,7 +10,7 @@ import type { KubbFile, PluginFactoryOptions, PluginManager } from '@kubb/core'
 import type { Plugin } from '@kubb/core'
 import type { HttpMethods as HttpMethod, MediaTypeObject, RequestBodyObject } from 'oas/types'
 import type { Oas, OasTypes, OpenAPIV3, Operation } from './oas/index.ts'
-import type { ContentType, Exclude, Include, OperationSchemas, Override, Paths } from './types.ts'
+import type { ContentType, Exclude, Include, OperationsByMethod, OperationSchemas, Override } from './types.ts'
 
 export type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never
 
@@ -339,7 +339,7 @@ export abstract class OperationGenerator<
 
             if (isIncluded && !isExcluded) {
               if (!acc[path]) {
-                acc[path] = {} as Paths['get']
+                acc[path] = {} as OperationsByMethod['get']
               }
               acc[path] = {
                 ...acc[path],
@@ -347,14 +347,14 @@ export abstract class OperationGenerator<
                   operation,
                   schemas: this.getSchemas(operation),
                 },
-              } as Paths['get']
+              } as OperationsByMethod['get']
             }
           }
         })
 
         return acc
       },
-      {} as Paths,
+      {} as OperationsByMethod,
     )
 
     const promises = Object.keys(filterdPaths).reduce(
@@ -362,10 +362,10 @@ export abstract class OperationGenerator<
         const methods = Object.keys(filterdPaths[path]!) as HttpMethod[]
 
         methods.forEach((method) => {
-          const { operation, schemas } = filterdPaths[path]![method]
+          const { operation } = filterdPaths[path]![method]
           const options = this.#getOptions(operation, method)
 
-          const promise = this.#methods[method].call(this, operation, schemas, { ...this.options, ...options })
+          const promise = this.#methods[method].call(this, operation, { ...this.options, ...options })
           if (promise) {
             acc.push(promise)
           }
@@ -376,7 +376,9 @@ export abstract class OperationGenerator<
       [] as OperationMethodResult<TFileMeta>[],
     )
 
-    promises.push(this.all(filterdPaths))
+    const operations = Object.values(filterdPaths).map(item => Object.values(item).map(item => item.operation))
+
+    promises.push(this.all(operations.flat(), filterdPaths))
 
     const files = await Promise.all(promises)
 
@@ -387,29 +389,29 @@ export abstract class OperationGenerator<
   /**
    * GET
    */
-  abstract get(operation: Operation, schemas: OperationSchemas, options: TOptions): OperationMethodResult<TFileMeta>
+  abstract get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>
 
   /**
    * POST
    */
-  abstract post(operation: Operation, schemas: OperationSchemas, options: TOptions): OperationMethodResult<TFileMeta>
+  abstract post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>
   /**
    * PATCH
    */
-  abstract patch(operation: Operation, schemas: OperationSchemas, options: TOptions): OperationMethodResult<TFileMeta>
+  abstract patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>
 
   /**
    * PUT
    */
-  abstract put(operation: Operation, schemas: OperationSchemas, options: TOptions): OperationMethodResult<TFileMeta>
+  abstract put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>
 
   /**
    * DELETE
    */
-  abstract delete(operation: Operation, schemas: OperationSchemas, options: TOptions): OperationMethodResult<TFileMeta>
+  abstract delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>
 
   /**
    * Combination of GET, POST, PATCH, PUT, DELETE
    */
-  abstract all(paths: Paths): OperationMethodResult<TFileMeta>
+  abstract all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>
 }
diff --git a/packages/swagger/src/components/Oas.tsx b/packages/swagger/src/components/Oas.tsx
new file mode 100644
index 000000000..4383064e6
--- /dev/null
+++ b/packages/swagger/src/components/Oas.tsx
@@ -0,0 +1,31 @@
+import { createContext } from '@kubb/react'
+
+import { Operation } from './Operation.tsx'
+
+import type { KubbNode } from '@kubb/react'
+import type { Oas as OasType, Operation as OperationType } from '../oas/index.ts'
+import type { OperationSchemas } from '../types.ts'
+
+export type GetSchemas = (operation: OperationType, statusCode?: string | number) => OperationSchemas
+
+type Props = {
+  oas: OasType
+  operations: OperationType[]
+  getSchemas: GetSchemas
+  children?: KubbNode
+}
+
+type OasContextProps = {
+  oas?: OasType
+  operations?: OperationType[]
+  getSchemas?: GetSchemas
+}
+
+const OasContext = createContext<OasContextProps>({})
+
+export function Oas({ oas, children, operations, getSchemas }: Props): KubbNode {
+  return <OasContext.Provider value={{ oas, getSchemas, operations }}>{children}</OasContext.Provider>
+}
+
+Oas.Context = OasContext
+Oas.Operation = Operation
diff --git a/packages/swagger/src/components/Operation.tsx b/packages/swagger/src/components/Operation.tsx
new file mode 100644
index 000000000..fe791a980
--- /dev/null
+++ b/packages/swagger/src/components/Operation.tsx
@@ -0,0 +1,31 @@
+import { createContext } from '@kubb/react'
+
+import type { KubbNode } from '@kubb/react'
+import type { Operation as OperationType } from '../oas/index.ts'
+import type { OperationSchemas } from '../types.ts'
+
+type Props = {
+  /**
+   * When no set it will be calculated based on useOas.getSchemas(see operationGenerator in Swagger)
+   * @deprecated better to use <Oas getSchemas /> on top of your component.
+   */
+  schemas?: OperationSchemas
+  operation: OperationType
+  children?: KubbNode
+}
+
+type OperationContextProps = {
+  /**
+   * @deprecated better to use <Oas getSchemas /> on top of your component.
+   */
+  schemas?: OperationSchemas
+  operation?: OperationType
+}
+
+const OperationContext = createContext<OperationContextProps>({})
+
+export function Operation({ schemas, operation, children }: Props): KubbNode {
+  return <OperationContext.Provider value={{ schemas, operation }}>{children}</OperationContext.Provider>
+}
+
+Operation.Context = OperationContext
diff --git a/packages/swagger/src/components/index.ts b/packages/swagger/src/components/index.ts
new file mode 100644
index 000000000..1879b1157
--- /dev/null
+++ b/packages/swagger/src/components/index.ts
@@ -0,0 +1,2 @@
+export { Oas } from './Oas.tsx'
+export { Operation } from './Operation.tsx'
diff --git a/packages/swagger/src/hooks/index.ts b/packages/swagger/src/hooks/index.ts
index d6b35c3d5..aa6a1ee11 100644
--- a/packages/swagger/src/hooks/index.ts
+++ b/packages/swagger/src/hooks/index.ts
@@ -1,3 +1,5 @@
 export { useOas } from './useOas.ts'
 export { useOperation, useOperationFile, useOperationName } from './useOperation.ts'
+export { useOperationHelpers } from './useOperationHelpers.ts'
+export { useOperations } from './useOperations.ts'
 export { useSchemas } from './useSchemas.ts'
diff --git a/packages/swagger/src/hooks/useOas.ts b/packages/swagger/src/hooks/useOas.ts
index a4139e73d..80e52e3b6 100644
--- a/packages/swagger/src/hooks/useOas.ts
+++ b/packages/swagger/src/hooks/useOas.ts
@@ -1,10 +1,21 @@
-import { useApp } from '@kubb/react'
+import { useContext } from '@kubb/react'
 
-import type { Oas } from '../oas/index.ts'
-import type { PluginOptions } from '../types.ts'
+import { Oas } from '../components/Oas.tsx'
 
-export function useOas(): Oas {
-  const { meta } = useApp<PluginOptions['appMeta']>()
+import type { GetSchemas } from '../components/Oas.tsx'
+import type { Oas as OasType } from '../oas/index.ts'
 
-  return meta.oas
+type Result = {
+  oas: OasType
+  getSchemas: GetSchemas
+}
+
+export function useOas(): Result {
+  const { oas, getSchemas } = useContext(Oas.Context)
+
+  if (!oas || !getSchemas) {
+    throw new Error('Oas is not defined')
+  }
+
+  return { oas, getSchemas }
 }
diff --git a/packages/swagger/src/hooks/useOperation.ts b/packages/swagger/src/hooks/useOperation.ts
index f96f0ff51..da92ba1ee 100644
--- a/packages/swagger/src/hooks/useOperation.ts
+++ b/packages/swagger/src/hooks/useOperation.ts
@@ -1,13 +1,19 @@
-import { useApp, useFile, usePlugin, usePluginManager } from '@kubb/react'
+import { useContext, usePlugin } from '@kubb/react'
+
+import { Operation } from '../components/Operation.tsx'
+import { useOperationHelpers } from './useOperationHelpers.ts'
 
 import type { KubbFile, Plugin, ResolveNameParams } from '@kubb/core'
-import type { Operation } from 'oas/operation'
-import type { PluginOptions, ResolvePathOptions } from '../types.ts'
+import type { Operation as OperationType } from '../oas/index.ts'
+
+export function useOperation(): OperationType {
+  const { operation } = useContext(Operation.Context)
 
-export function useOperation(): Operation {
-  const { meta } = useApp<PluginOptions['appMeta']>()
+  if (!operation) {
+    throw new Error('Operation is not defined')
+  }
 
-  return meta.operation
+  return operation
 }
 
 type UseOperationNameProps = {
@@ -17,12 +23,15 @@ type UseOperationNameProps = {
 
 export function useOperationName({ type, ...rest }: UseOperationNameProps): string {
   const plugin = usePlugin()
-  const pluginManager = usePluginManager()
   const operation = useOperation()
+  const { getOperationName } = useOperationHelpers({ operation })
 
   const pluginKey = rest.pluginKey || plugin.key
 
-  return pluginManager.resolveName({ name: operation.getOperationId(), pluginKey, type })
+  return getOperationName({
+    pluginKey,
+    type,
+  })
 }
 
 type FileMeta = KubbFile.FileMetaBase & {
@@ -40,20 +49,13 @@ export function useOperationFile(props: UseOperationFileProps = {}): KubbFile.Fi
   const plugin = usePlugin()
   const operation = useOperation()
 
+  const { getOperationFile } = useOperationHelpers({ operation })
+
   const pluginKey = props.pluginKey || plugin.key
-  // needed for the `output.group`
-  const tag = operation?.getTags().at(0)?.name
-  const name = useOperationName({ type: 'file', pluginKey })
   const extName = props.extName || '.ts'
-  const file = useFile<ResolvePathOptions>({ name, extName, pluginKey, options: { type: 'file', pluginKey, tag } })
-
-  return {
-    ...file,
-    meta: {
-      ...file.meta,
-      name,
-      pluginKey,
-      tag,
-    },
-  }
+
+  return getOperationFile({
+    pluginKey,
+    extName,
+  })
 }
diff --git a/packages/swagger/src/hooks/useOperationHelpers.ts b/packages/swagger/src/hooks/useOperationHelpers.ts
new file mode 100644
index 000000000..a03437501
--- /dev/null
+++ b/packages/swagger/src/hooks/useOperationHelpers.ts
@@ -0,0 +1,50 @@
+import { usePluginManager } from '@kubb/react'
+
+import type { KubbFile, Plugin, ResolveNameParams } from '@kubb/core'
+import type { Operation as OperationType } from '../oas/index.ts'
+
+type FileMeta = KubbFile.FileMetaBase & {
+  pluginKey: Plugin['key']
+  name: string
+  tag?: string
+}
+
+type UseOperationHelpersProps = {
+  operation: OperationType
+}
+
+type UseOperationHelpersResult = {
+  getOperationName: (params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => string
+  getOperationFile: (params: { pluginKey: Plugin['key']; extName?: KubbFile.Extname }) => KubbFile.File<FileMeta>
+}
+
+export function useOperationHelpers({ operation }: UseOperationHelpersProps): UseOperationHelpersResult {
+  const pluginManager = usePluginManager()
+
+  const getOperationName: UseOperationHelpersResult['getOperationName'] = ({ pluginKey, type }) => {
+    return pluginManager.resolveName({ name: operation.getOperationId(), pluginKey, type })
+  }
+
+  const getOperationFile: UseOperationHelpersResult['getOperationFile'] = ({ pluginKey, extName = '.ts' }) => {
+    // needed for the `output.group`
+    const tag = operation?.getTags().at(0)?.name
+    const name = getOperationName({ type: 'file', pluginKey })
+
+    const file = pluginManager.getFile({ name, extName, pluginKey, options: { type: 'file', pluginKey, tag } })
+
+    return {
+      ...file,
+      meta: {
+        ...file.meta,
+        name,
+        pluginKey,
+        tag,
+      },
+    }
+  }
+
+  return {
+    getOperationName,
+    getOperationFile,
+  }
+}
diff --git a/packages/swagger/src/hooks/useOperations.ts b/packages/swagger/src/hooks/useOperations.ts
new file mode 100644
index 000000000..7fc0ae486
--- /dev/null
+++ b/packages/swagger/src/hooks/useOperations.ts
@@ -0,0 +1,37 @@
+import { useContext } from '@kubb/react'
+
+import { Oas } from '../components/Oas.tsx'
+
+import type { HttpMethod, Operation } from '../oas/index.ts'
+
+type UseOperationsProps = {
+  /**
+   * Filter based on path
+   * Weight: 2
+   */
+  path?: string
+  /**
+   * Filter based on method
+   * Weight: 1
+   */
+  method?: HttpMethod
+}
+
+export function useOperations({ method, path }: UseOperationsProps = {}): Operation[] {
+  const { operations } = useContext(Oas.Context)
+
+  if (!operations) {
+    throw new Error('Operations is not defined')
+  }
+  let items = operations
+
+  if (path) {
+    items = items.filter(item => item.path === path)
+  }
+
+  if (method) {
+    items = items.filter(item => item.method === method)
+  }
+
+  return items
+}
diff --git a/packages/swagger/src/hooks/useSchemas.ts b/packages/swagger/src/hooks/useSchemas.ts
index 450dadb36..d0c2ecac8 100644
--- a/packages/swagger/src/hooks/useSchemas.ts
+++ b/packages/swagger/src/hooks/useSchemas.ts
@@ -1,9 +1,24 @@
-import { useApp } from '@kubb/react'
+import { useContext } from '@kubb/react'
 
-import type { OperationSchemas, PluginOptions } from '../types.ts'
+import { Oas } from '../components/Oas.tsx'
+import { Operation } from '../components/Operation.tsx'
 
+import type { OperationSchemas } from '../types.ts'
+
+/**
+ * When no schemas is set it will call `getSchemas` of `useOas` based on the current operation.
+ */
 export function useSchemas(): OperationSchemas {
-  const { meta } = useApp<PluginOptions['appMeta']>()
+  const { getSchemas } = useContext(Oas.Context)
+  const { schemas, operation } = useContext(Operation.Context)
+
+  if (getSchemas && operation) {
+    return getSchemas(operation)
+  }
+
+  if (!schemas) {
+    throw new Error(`Schemas is not defined for operations ${operation?.path || 'unknown operation'}`)
+  }
 
-  return meta.schemas
+  return schemas
 }
diff --git a/packages/swagger/src/types.ts b/packages/swagger/src/types.ts
index 2f6c55773..534a2d849 100644
--- a/packages/swagger/src/types.ts
+++ b/packages/swagger/src/types.ts
@@ -1,7 +1,6 @@
 import type { Plugin } from '@kubb/core'
 import type { KubbFile, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { SchemaObject } from 'oas/types'
-import type { HttpMethod, Oas, Operation } from './oas/index.ts'
+import type { HttpMethod, Oas, Operation, SchemaObject } from './oas/index.ts'
 import type { GetSchemasProps } from './utils/getSchemas.ts'
 
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -97,7 +96,7 @@ export type OperationSchemas = {
   errors?: Array<OperationSchema>
 }
 
-export type Paths = Record<string, Record<HttpMethod, { operation: Operation; schemas: OperationSchemas }>>
+export type OperationsByMethod = Record<string, Record<HttpMethod, { operation: Operation; schemas: OperationSchemas }>>
 
 type ByTag = {
   type: 'tag'
@@ -124,15 +123,13 @@ export type Include = ByTag | ByOperationId | ByPath | ByMethod
 
 export type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod) & { options: Partial<TOptions> }
 
-export type AppMeta = { schemas: OperationSchemas; operation: Operation; oas: Oas }
-
 export type ImportMeta = {
   ref: Ref
   path: string
   isTypeOnly: boolean
 }
 
-export type PluginOptions = PluginFactoryOptions<'swagger', Options, Options, API, never, AppMeta>
+export type PluginOptions = PluginFactoryOptions<'swagger', Options, Options, API, never>
 
 declare module '@kubb/core' {
   export interface _Register {
diff --git a/packages/swagger/tsup.config.ts b/packages/swagger/tsup.config.ts
index 5182b460a..8999656fb 100644
--- a/packages/swagger/tsup.config.ts
+++ b/packages/swagger/tsup.config.ts
@@ -8,6 +8,7 @@ export default defineConfig([
     entry: {
       index: 'src/index.ts',
       utils: 'src/utils/index.ts',
+      components: 'src/components/index.ts',
       hooks: 'src/hooks/index.ts',
       oas: 'src/oas/index.ts',
     },
@@ -17,6 +18,7 @@ export default defineConfig([
     entry: {
       index: 'src/index.ts',
       utils: 'src/utils/index.ts',
+      components: 'src/components/index.ts',
       hooks: 'src/hooks/index.ts',
       oas: 'src/oas/index.ts',
     },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 000d58466..2b994d39f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1343,6 +1343,9 @@ importers:
       eslint:
         specifier: ^8.57.0
         version: 8.57.0
+      react:
+        specifier: ^18.2.0
+        version: 18.2.0
       tsup:
         specifier: ^8.0.2
         version: 8.0.2(@microsoft/api-extractor@7.42.3)(ts-node@10.9.2)(typescript@5.4.2)
diff --git a/tsconfig.json b/tsconfig.json
index eedc76418..bc2d12741 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -38,6 +38,9 @@
       "@kubb/swagger/utils": [
         "packages/swagger/src/utils/index.ts"
       ],
+      "@kubb/swagger/components": [
+        "packages/swagger/src/components/index.ts"
+      ],
       "@kubb/swagger": [
         "packages/swagger/src/index.ts"
       ],