@kubb/plugin-oas 5.0.0-alpha.3 → 5.0.0-alpha.30

package/src/SchemaGenerator.ts

@@ -1,38 +1,32 @@
+import type { AsyncEventEmitter } from '@internals/utils'
 import { getUniqueName, pascalCase, stringify } from '@internals/utils'
-import type { AsyncEventEmitter, FileMetaBase, KubbEvents, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from '@kubb/core'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FileMetaBase, KubbEvents, Plugin, PluginDriver, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { FabricFile, Fabric as FabricType } from '@kubb/fabric-core/types'
 import type { contentType, Oas, OasTypes, OpenAPIV3, SchemaObject } from '@kubb/oas'
 import { isDiscriminator, isNullable, isReference, KUBB_INLINE_REF_PREFIX } from '@kubb/oas'
-import type { Fabric } from '@kubb/react-fabric'
-import pLimit from 'p-limit'
 import { isDeepEqual, isNumber, uniqueWith } from 'remeda'
 import type { CoreGenerator } from './generators/createGenerator.ts'
 import type { ReactGenerator } from './generators/createReactGenerator.ts'
-import type { Generator, Version } from './generators/types.ts'
+import type { Generator } from './generators/types.ts'
 import { isKeyword, type Schema, type SchemaKeywordMapper, schemaKeywords } from './SchemaMapper.ts'
 import type { OperationSchema, Override, Refs } from './types.ts'
 import { getSchemaFactory } from './utils/getSchemaFactory.ts'
-import { buildSchema } from './utils.tsx'
+import { renderSchema } from './utils.tsx'
 
 export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
 
-export type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
-
-/** Max concurrent generator tasks (across generators). */
-const GENERATOR_CONCURRENCY = 3
-/** Max concurrent schema parsing tasks (per generator). */
-const SCHEMA_CONCURRENCY = 30
+export type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<FabricFile.File<TFileMeta> | Array<FabricFile.File<TFileMeta>> | null>
 
 type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
-  fabric: Fabric
+  fabric: FabricType
   oas: Oas
-  pluginManager: PluginManager
+  driver: PluginDriver
   events?: AsyncEventEmitter<KubbEvents>
   /**
    * Current plugin
    */
   plugin: Plugin<TPluginOptions>
-  mode: KubbFile.Mode
+  mode: FabricFile.Mode
   include?: Array<'schemas' | 'responses' | 'requestBodies'>
   override: Array<Override<TOptions>> | undefined
   contentType?: contentType
@@ -524,18 +518,18 @@ export class SchemaGenerator<
     // Use the full $ref path to look up the collision-resolved name
     const resolvedName = this.#schemaNameMapping.get($ref) || originalName
 
-    const propertyName = this.context.pluginManager.resolveName({
+    const propertyName = this.context.driver.resolveName({
       name: resolvedName,
       pluginName: this.context.plugin.name,
       type: 'function',
     })
 
-    const fileName = this.context.pluginManager.resolveName({
+    const fileName = this.context.driver.resolveName({
       name: resolvedName,
       pluginName: this.context.plugin.name,
       type: 'file',
     })
-    const file = this.context.pluginManager.getFile({
+    const file = this.context.driver.getFile({
       name: fileName,
       pluginName: this.context.plugin.name,
       extname: '.ts',
@@ -968,7 +962,7 @@ export class SchemaGenerator<
       const enumName = useCollisionDetection
         ? pascalCase(enumNameParts.join(' '))
         : getUniqueName(pascalCase(enumNameParts.join(' ')), this.options.usedEnumNames || {})
-      const typeName = this.context.pluginManager.resolveName({
+      const typeName = this.context.driver.resolveName({
         name: enumName,
         pluginName: this.context.plugin.name,
         type: 'type',
@@ -1337,7 +1331,7 @@ export class SchemaGenerator<
     return [{ keyword: emptyType }, ...baseItems]
   }
 
-  async build(...generators: Array<Generator<TPluginOptions, Version>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<FabricFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
     // Initialize the name mapping if not already done
@@ -1360,83 +1354,68 @@ export class SchemaGenerator<
     return this.#doBuild(schemas, generators)
   }
 
-  async #doBuild(
-    schemas: Record<string, OasTypes.SchemaObject>,
-    generators: Array<Generator<TPluginOptions, Version>>,
-  ): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async #doBuild(schemas: Record<string, OasTypes.SchemaObject>, generators: Array<Generator<TPluginOptions>>): Promise<Array<FabricFile.File<TFileMeta>>> {
     const schemaEntries = Object.entries(schemas)
 
-    const generatorLimit = pLimit(GENERATOR_CONCURRENCY)
-    const schemaLimit = pLimit(SCHEMA_CONCURRENCY)
+    const results: Array<FabricFile.File<TFileMeta>> = []
 
-    const writeTasks = generators.map((generator) =>
-      generatorLimit(async () => {
-        if (generator.version === '2') {
-          return []
-        }
+    for (const generator of generators) {
+      if (!('type' in generator)) {
+        continue
+      }
 
-        // After the v2 guard above, all generators here are v1
-        const v1Generator = generator as ReactGenerator<TPluginOptions, '1'> | CoreGenerator<TPluginOptions, '1'>
+      // After the v2 guard above, all generators here are v1
+      const v1Generator = generator as ReactGenerator<TPluginOptions> | CoreGenerator<TPluginOptions>
 
-        const schemaTasks = schemaEntries.map(([name, schemaObject]) =>
-          schemaLimit(async () => {
-            const options = this.#getOptions(name)
+      for (const [name, schemaObject] of schemaEntries) {
+        const options = this.#getOptions(name)
 
-            const tree = this.parse({ schema: schemaObject as SchemaObject, name, parentName: null, rootName: name })
+        const tree = this.parse({ schema: schemaObject as SchemaObject, name, parentName: null, rootName: name })
 
-            if (v1Generator.type === 'react') {
-              await buildSchema(
-                {
-                  name,
-                  value: schemaObject as SchemaObject,
-                  tree,
-                },
-                {
-                  config: this.context.pluginManager.config,
-                  fabric: this.context.fabric,
-                  Component: v1Generator.Schema,
-                  generator: this,
-                  plugin: {
-                    ...this.context.plugin,
-                    options: {
-                      ...this.options,
-                      ...options,
-                    },
-                  },
-                },
-              )
-
-              return []
-            }
-
-            const result = await v1Generator.schema?.({
-              config: this.context.pluginManager.config,
+        if (v1Generator.type === 'react') {
+          await renderSchema(
+            {
+              name,
+              value: schemaObject as SchemaObject,
+              tree,
+            },
+            {
+              config: this.context.driver.config,
+              fabric: this.context.fabric,
+              Component: v1Generator.Schema,
               generator: this,
-              schema: {
-                name,
-                value: schemaObject as SchemaObject,
-                tree,
-              },
               plugin: {
                 ...this.context.plugin,
                 options: {
                   ...this.options,
                   ...options,
-                },
+                } as unknown as Plugin<TPluginOptions>['options'],
               },
-            })
-
-            return result ?? []
-          }),
-        )
-
-        const schemaResults = await Promise.all(schemaTasks)
-        return schemaResults.flat() as unknown as KubbFile.File<TFileMeta>
-      }),
-    )
+            },
+          )
+        } else {
+          const result = await v1Generator.schema?.({
+            config: this.context.driver.config,
+            generator: this,
+            schema: {
+              name,
+              value: schemaObject as SchemaObject,
+              tree,
+            },
+            plugin: {
+              ...this.context.plugin,
+              options: {
+                ...this.options,
+                ...options,
+              } as unknown as Plugin<TPluginOptions>['options'],
+            },
+          })
 
-    const nestedResults = await Promise.all(writeTasks)
+          results.push(...([result ?? []].flat() as Array<FabricFile.File<TFileMeta>>))
+        }
+      }
+    }
 
-    return nestedResults.flat()
+    return results
   }
 }

package/src/SchemaMapper.ts

@@ -1,4 +1,4 @@
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import type { SchemaObject } from '@kubb/oas'
 
 export type SchemaKeywordMapper = {
@@ -59,7 +59,7 @@ export type SchemaKeywordMapper = {
       /**
        * Full qualified path.
        */
-      path: KubbFile.Path
+      path: FabricFile.Path
       /**
        * When true `File.Import` is used.
        * When false a reference is used inside the current file.

package/src/generators/createGenerator.ts

@@ -1,30 +1,27 @@
 import type { PluginFactoryOptions } from '@kubb/core'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { OperationProps, OperationsProps, SchemaProps, Version } from './types.ts'
+import type { FabricFile } from '@kubb/fabric-core/types'
+import type { OperationProps, OperationsProps, SchemaProps } from './types.ts'
 
-type UserGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
+type UserGenerator<TOptions extends PluginFactoryOptions> = {
   name: string
-  version?: TVersion
-  operations?: (props: OperationsProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
-  operation?: (props: OperationProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
-  schema?: (props: SchemaProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
+  operations?: (props: OperationsProps<TOptions>) => Promise<FabricFile.File[]>
+  operation?: (props: OperationProps<TOptions>) => Promise<FabricFile.File[]>
+  schema?: (props: SchemaProps<TOptions>) => Promise<FabricFile.File[]>
 }
 
-export type CoreGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
+export type CoreGenerator<TOptions extends PluginFactoryOptions> = {
   name: string
   type: 'core'
-  version: TVersion
-  operations: (props: OperationsProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
-  operation: (props: OperationProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
-  schema: (props: SchemaProps<TOptions, TVersion>) => Promise<KubbFile.File[]>
+  version: '1'
+  operations: (props: OperationsProps<TOptions>) => Promise<FabricFile.File[]>
+  operation: (props: OperationProps<TOptions>) => Promise<FabricFile.File[]>
+  schema: (props: SchemaProps<TOptions>) => Promise<FabricFile.File[]>
 }
 
-export function createGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'>(
-  generator: UserGenerator<TOptions, TVersion>,
-): CoreGenerator<TOptions, TVersion> {
+export function createGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): CoreGenerator<TOptions> {
   return {
     type: 'core',
-    version: (generator.version ?? '1') as TVersion,
+    version: '1',
     async operations() {
       return []
     },

package/src/generators/createReactGenerator.ts

@@ -1,22 +1,21 @@
 import type { PluginFactoryOptions } from '@kubb/core'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { OperationProps, OperationsProps, SchemaProps, Version } from './types.ts'
+import type { OperationProps, OperationsProps, SchemaProps } from './types.ts'
 
-type UserGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
+type UserGenerator<TOptions extends PluginFactoryOptions> = {
   name: string
-  version?: TVersion
-  Operations?: (props: OperationsProps<TOptions, TVersion>) => FabricReactNode
-  Operation?: (props: OperationProps<TOptions, TVersion>) => FabricReactNode
-  Schema?: (props: SchemaProps<TOptions, TVersion>) => FabricReactNode
+  Operations?: (props: OperationsProps<TOptions>) => FabricReactNode
+  Operation?: (props: OperationProps<TOptions>) => FabricReactNode
+  Schema?: (props: SchemaProps<TOptions>) => FabricReactNode
 }
 
-export type ReactGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
+export type ReactGenerator<TOptions extends PluginFactoryOptions> = {
   name: string
   type: 'react'
-  version: TVersion
-  Operations: (props: OperationsProps<TOptions, TVersion>) => FabricReactNode
-  Operation: (props: OperationProps<TOptions, TVersion>) => FabricReactNode
-  Schema: (props: SchemaProps<TOptions, TVersion>) => FabricReactNode
+  version: '1'
+  Operations: (props: OperationsProps<TOptions>) => FabricReactNode
+  Operation: (props: OperationProps<TOptions>) => FabricReactNode
+  Schema: (props: SchemaProps<TOptions>) => FabricReactNode
 }
 
 /****
@@ -26,12 +25,10 @@ export type ReactGenerator<TOptions extends PluginFactoryOptions, TVersion exten
  *
  * @returns A generator object with async methods for operations, operation, and schema file generation.
  */
-export function createReactGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'>(
-  generator: UserGenerator<TOptions, TVersion>,
-): ReactGenerator<TOptions, TVersion> {
+export function createReactGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): ReactGenerator<TOptions> {
   return {
     type: 'react',
-    version: (generator.version ?? '1') as TVersion,
+    version: '1',
     Operations() {
       return null
     },

package/src/generators/index.ts

@@ -1,4 +1,4 @@
-export { createGenerator } from './createGenerator.ts'
-export { createReactGenerator } from './createReactGenerator.ts'
+export { type CoreGenerator, createGenerator } from './createGenerator.ts'
+export { createReactGenerator, type ReactGenerator } from './createReactGenerator.ts'
 export { jsonGenerator } from './jsonGenerator.ts'
 export type { Generator } from './types.ts'

package/src/generators/jsonGenerator.ts

@@ -7,8 +7,8 @@ import { createGenerator } from './createGenerator.ts'
 export const jsonGenerator = createGenerator<PluginOas>({
   name: 'plugin-oas',
   async schema({ schema, generator }) {
-    const { pluginManager, plugin } = generator.context
-    const file = pluginManager.getFile({
+    const { driver, plugin } = generator.context
+    const file = driver.getFile({
       name: camelCase(schema.name),
       extname: '.json',
       mode: 'split',
@@ -29,7 +29,7 @@ export const jsonGenerator = createGenerator<PluginOas>({
         banner: getBanner({
           oas: generator.context.oas,
           output: plugin.options.output,
-          config: pluginManager.config,
+          config: driver.config,
         }),
         format: getFooter({ oas: generator.context.oas, output: plugin.options.output }),
       },

package/src/generators/types.ts

@@ -1,5 +1,4 @@
-import type { OperationNode, SchemaNode } from '@kubb/ast/types'
-import type { Adapter, Config, Plugin, PluginFactoryOptions } from '@kubb/core'
+import type { Config, Generator as CoreV2Generator, Plugin, PluginFactoryOptions } from '@kubb/core'
 import type { Operation, SchemaObject } from '@kubb/oas'
 import type { OperationGenerator } from '../OperationGenerator.ts'
 import type { SchemaGenerator, SchemaGeneratorOptions } from '../SchemaGenerator.ts'
@@ -7,45 +6,21 @@ import type { Schema } from '../SchemaMapper.ts'
 import type { CoreGenerator } from './createGenerator.ts'
 import type { ReactGenerator } from './createReactGenerator.ts'
 
-export type Version = '1' | '2'
-
-export type OperationsV1Props<TOptions extends PluginFactoryOptions> = {
+export type OperationsProps<TOptions extends PluginFactoryOptions> = {
   config: Config
   generator: Omit<OperationGenerator<TOptions>, 'build'>
   plugin: Plugin<TOptions>
   operations: Array<Operation>
 }
 
-export type OperationsV2Props<TOptions extends PluginFactoryOptions> = {
-  config: Config
-  adapter: Adapter
-  options: Plugin<TOptions>['options']
-  nodes: Array<OperationNode>
-}
-
-export type OperationV1Props<TOptions extends PluginFactoryOptions> = {
+export type OperationProps<TOptions extends PluginFactoryOptions> = {
   config: Config
   generator: Omit<OperationGenerator<TOptions>, 'build'>
   plugin: Plugin<TOptions>
   operation: Operation
 }
 
-export type OperationV2Props<TOptions extends PluginFactoryOptions> = {
-  config: Config
-  adapter: Adapter
-  options: Plugin<TOptions>['options']
-  node: OperationNode
-}
-
-export type OperationsProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2'
-  ? OperationsV2Props<TOptions>
-  : OperationsV1Props<TOptions>
-
-export type OperationProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2'
-  ? OperationV2Props<TOptions>
-  : OperationV1Props<TOptions>
-
-export type SchemaV1Props<TOptions extends PluginFactoryOptions> = {
+export type SchemaProps<TOptions extends PluginFactoryOptions> = {
   config: Config
   generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
   plugin: Plugin<TOptions>
@@ -56,17 +31,4 @@ export type SchemaV1Props<TOptions extends PluginFactoryOptions> = {
   }
 }
 
-export type SchemaV2Props<TOptions extends PluginFactoryOptions> = {
-  config: Config
-  options: Plugin<TOptions>['options']
-  node: SchemaNode
-  adapter: Adapter
-}
-
-export type SchemaProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2'
-  ? SchemaV2Props<TOptions>
-  : SchemaV1Props<TOptions>
-
-export type Generator<TOptions extends PluginFactoryOptions, TVersion extends Version = Version> =
-  | CoreGenerator<TOptions, TVersion>
-  | ReactGenerator<TOptions, TVersion>
+export type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions> | CoreV2Generator<TOptions>

package/src/hooks/useOas.ts

@@ -1,9 +1,12 @@
 import type { Oas } from '@kubb/oas'
 
-import { useApp } from '@kubb/react-fabric'
+import { useFabric } from '@kubb/react-fabric'
 
+/**
+ * @deprecated use schemaNode or operationNode instead
+ */
 export function useOas(): Oas {
-  const { meta } = useApp<{ oas: Oas }>()
+  const { meta } = useFabric<{ oas: Oas }>()
 
   return meta.oas
 }

package/src/hooks/useOperationManager.ts

@@ -1,6 +1,6 @@
 import type { FileMetaBase, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import { usePlugin, usePluginManager } from '@kubb/core/hooks'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import { useDriver, usePlugin } from '@kubb/core/hooks'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import type { Operation, Operation as OperationType } from '@kubb/oas'
 import type { OperationGenerator } from '../OperationGenerator.ts'
 import type { OperationSchemas } from '../types.ts'
@@ -41,13 +41,13 @@ type UseOperationManagerResult = {
       prefix?: string
       suffix?: string
       pluginName?: string
-      extname?: KubbFile.Extname
+      extname?: FabricFile.Extname
       group?: {
         tag?: string
         path?: string
       }
     },
-  ) => KubbFile.File<FileMeta>
+  ) => FabricFile.File<FileMeta>
   groupSchemasByName: (
     operation: OperationType,
     params: {
@@ -66,10 +66,11 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
   generator: Omit<OperationGenerator<TPluginOptions>, 'build'>,
 ): UseOperationManagerResult {
   const plugin = usePlugin()
-  const pluginManager = usePluginManager()
+  const driver = useDriver()
+  const defaultPluginName = plugin.name
 
-  const getName: UseOperationManagerResult['getName'] = (operation, { prefix = '', suffix = '', pluginName = plugin.name, type }) => {
-    return pluginManager.resolveName({
+  const getName: UseOperationManagerResult['getName'] = (operation, { prefix = '', suffix = '', pluginName = defaultPluginName, type }) => {
+    return driver.resolveName({
       name: `${prefix} ${operation.getOperationId()} ${suffix}`,
       pluginName,
       type,
@@ -78,7 +79,7 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
 
   const getGroup: UseOperationManagerResult['getGroup'] = (operation) => {
     return {
-      tag: operation.getTags().at(0)?.name,
+      tag: operation.getTags().at(0)?.name ?? 'default',
       path: operation.path,
     }
   }
@@ -90,19 +91,19 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
 
     return generator.getSchemas(operation, {
       resolveName: (name) =>
-        pluginManager.resolveName({
+        driver.resolveName({
           name,
-          pluginName: params?.pluginName,
+          pluginName: params?.pluginName ?? defaultPluginName,
           type: params?.type,
         }),
     })
   }
 
-  const getFile: UseOperationManagerResult['getFile'] = (operation, { prefix, suffix, pluginName = plugin.name, extname = '.ts' } = {}) => {
+  const getFile: UseOperationManagerResult['getFile'] = (operation, { prefix, suffix, pluginName = defaultPluginName, extname = '.ts' } = {}) => {
     const name = getName(operation, { type: 'file', pluginName, prefix, suffix })
     const group = getGroup(operation)
 
-    const file = pluginManager.getFile({
+    const file = driver.getFile({
       name,
       extname,
       pluginName,
@@ -120,12 +121,12 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
     }
   }
 
-  const groupSchemasByName: UseOperationManagerResult['groupSchemasByName'] = (operation, { pluginName = plugin.name, type }) => {
+  const groupSchemasByName: UseOperationManagerResult['groupSchemasByName'] = (operation, { pluginName = defaultPluginName, type }) => {
     if (!generator) {
       throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`)
     }
 
-    const schemas = generator.getSchemas(operation)
+    const schemas = getSchemas(operation)
 
     const errors = (schemas.errors || []).reduce(
       (prev, acc) => {
@@ -133,7 +134,7 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
           return prev
         }
 
-        prev[acc.statusCode] = pluginManager.resolveName({
+        prev[acc.statusCode] = driver.resolveName({
           name: acc.name,
           pluginName,
           type,
@@ -150,7 +151,7 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
           return prev
         }
 
-        prev[acc.statusCode] = pluginManager.resolveName({
+        prev[acc.statusCode] = driver.resolveName({
           name: acc.name,
           pluginName,
           type,
@@ -163,7 +164,7 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
 
     return {
       request: schemas.request?.name
-        ? pluginManager.resolveName({
+        ? driver.resolveName({
             name: schemas.request.name,
             pluginName,
             type,
@@ -171,21 +172,21 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
         : undefined,
       parameters: {
         path: schemas.pathParams?.name
-          ? pluginManager.resolveName({
+          ? driver.resolveName({
               name: schemas.pathParams.name,
               pluginName,
               type,
             })
           : undefined,
         query: schemas.queryParams?.name
-          ? pluginManager.resolveName({
+          ? driver.resolveName({
               name: schemas.queryParams.name,
               pluginName,
               type,
             })
           : undefined,
         header: schemas.headerParams?.name
-          ? pluginManager.resolveName({
+          ? driver.resolveName({
               name: schemas.headerParams.name,
               pluginName,
               type,
@@ -194,7 +195,7 @@ export function useOperationManager<TPluginOptions extends PluginFactoryOptions
       },
       responses: {
         ...responses,
-        ['default']: pluginManager.resolveName({
+        ['default']: driver.resolveName({
           name: schemas.response.name,
           pluginName,
           type,

package/src/hooks/useSchemaManager.ts

@@ -1,6 +1,6 @@
 import type { FileMetaBase, ResolveNameParams } from '@kubb/core'
-import { usePlugin, usePluginManager } from '@kubb/core/hooks'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import { useDriver, usePlugin } from '@kubb/core/hooks'
+import type { FabricFile } from '@kubb/fabric-core/types'
 
 type FileMeta = FileMetaBase & {
   pluginName: string
@@ -17,14 +17,14 @@ type UseSchemaManagerResult = {
     name: string,
     params?: {
       pluginName?: string
-      mode?: KubbFile.Mode
-      extname?: KubbFile.Extname
+      mode?: FabricFile.Mode
+      extname?: FabricFile.Extname
       group?: {
         tag?: string
         path?: string
       }
     },
-  ) => KubbFile.File<FileMeta>
+  ) => FabricFile.File<FileMeta>
 }
 
 /**
@@ -33,10 +33,10 @@ type UseSchemaManagerResult = {
  */
 export function useSchemaManager(): UseSchemaManagerResult {
   const plugin = usePlugin()
-  const pluginManager = usePluginManager()
+  const driver = useDriver()
 
   const getName: UseSchemaManagerResult['getName'] = (name, { pluginName = plugin.name, type }) => {
-    return pluginManager.resolveName({
+    return driver.resolveName({
       name,
       pluginName,
       type,
@@ -46,7 +46,7 @@ export function useSchemaManager(): UseSchemaManagerResult {
   const getFile: UseSchemaManagerResult['getFile'] = (name, { mode = 'split', pluginName = plugin.name, extname = '.ts', group } = {}) => {
     const resolvedName = mode === 'single' ? '' : getName(name, { type: 'file', pluginName })
 
-    const file = pluginManager.getFile({
+    const file = driver.getFile({
       name: resolvedName,
       extname,
       pluginName,

package/src/index.ts

@@ -25,7 +25,7 @@ export type {
 } from './SchemaMapper.ts'
 export { isKeyword, schemaKeywords } from './SchemaMapper.ts'
 export type * from './types.ts'
-export { buildOperation, buildOperations, buildSchema } from './utils.tsx'
+export { renderOperation, renderOperations, renderSchema } from './utils.tsx'
 
 /**
  * @deprecated use `import { createGenerator } from '@kubb/plugin-oas/generators'`
@@ -40,4 +40,4 @@ export const createReactGenerator = _createReactGenerator
 /**
  * @deprecated use `import { Generator } from '@kubb/plugin-oas/generators'`
  */
-export type Generator<TOptions extends PluginFactoryOptions, TVersion extends import('./generators/types.ts').Version = '1'> = _Generator<TOptions, TVersion>
+export type Generator<TOptions extends PluginFactoryOptions> = _Generator<TOptions>