@kubb/plugin-oas 3.0.0-alpha.8 → 3.0.0-beta.1

package/src/OperationGenerator.ts

@@ -1,4 +1,4 @@
-import { type FileMetaBase, Generator } from '@kubb/core'
+import { BaseGenerator, type FileMetaBase } from '@kubb/core'
 import transformers from '@kubb/core/transformers'
 
 import type { PluginFactoryOptions, PluginManager } from '@kubb/core'
@@ -6,10 +6,13 @@ import type * as KubbFile from '@kubb/fs/types'
 
 import type { Plugin } from '@kubb/core'
 import type { HttpMethod, Oas, OasTypes, Operation, contentType } from '@kubb/oas'
+import type { Generator } from './generator.tsx'
 import type { Exclude, Include, OperationSchemas, OperationsByMethod, Override } from './types.ts'
-import type { Parser } from './parser.tsx'
 
-export type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never
+/**
+ * @deprecated
+ */
+export type GetOperationGeneratorOptions<T = any> = any
 
 export type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
 
@@ -28,10 +31,9 @@ type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
 }
 
 export class OperationGenerator<
-  TOptions = unknown,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
   #operationsByMethod: OperationsByMethod = {}
   get operationsByMethod(): OperationsByMethod {
     return this.#operationsByMethod
@@ -41,7 +43,7 @@ export class OperationGenerator<
     this.#operationsByMethod = paths
   }
 
-  #getOptions(operation: Operation, method: HttpMethod): Partial<TOptions> {
+  #getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']> {
     const { override = [] } = this.context
 
     return (
@@ -67,10 +69,6 @@ export class OperationGenerator<
     )
   }
 
-  /**
-   *
-   * @deprecated
-   */
   #isExcluded(operation: Operation, method: HttpMethod): boolean {
     const { exclude = [] } = this.context
     let matched = false
@@ -96,10 +94,6 @@ export class OperationGenerator<
     return matched
   }
 
-  /**
-   *
-   * @deprecated
-   */
   #isIncluded(operation: Operation, method: HttpMethod): boolean {
     const { include = [] } = this.context
     let matched = false
@@ -128,10 +122,8 @@ export class OperationGenerator<
   getSchemas(
     operation: Operation,
     {
-      forStatusCode,
       resolveName = (name) => name,
     }: {
-      forStatusCode?: string | number
       resolveName?: (name: string) => string
     } = {},
   ): OperationSchemas {
@@ -139,8 +131,7 @@ export class OperationGenerator<
     const queryParamsSchema = this.context.oas.getParametersSchema(operation, 'query')
     const headerParamsSchema = this.context.oas.getParametersSchema(operation, 'header')
     const requestSchema = this.context.oas.getRequestSchema(operation)
-    const responseStatusCode =
-      forStatusCode || (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
+    const responseStatusCode = (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
     const responseSchema = this.context.oas.getResponseSchema(operation, responseStatusCode)
     const statusCodes = operation.getResponseStatusCodes().map((statusCode) => {
       let name = statusCode
@@ -226,7 +217,9 @@ export class OperationGenerator<
     }
   }
 
-  async build(...parsers: Array<Parser<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  #methods = ['get', 'post', 'patch', 'put', 'delete']
+
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas } = this.context
 
     const paths = oas.getPaths()
@@ -235,7 +228,7 @@ export class OperationGenerator<
 
       methods.forEach((method) => {
         const operation = oas.operation(path, method)
-        if (operation) {
+        if (operation && [this.#methods].some((methods) => method === operation.method)) {
           const isExcluded = this.#isExcluded(operation, method)
           const isIncluded = this.context.include ? this.#isIncluded(operation, method) : true
 
@@ -286,8 +279,8 @@ export class OperationGenerator<
           acc.push(promiseOperation)
         }
 
-        parsers?.forEach((parser) => {
-          const promise = parser.operation?.({
+        generators?.forEach((generator) => {
+          const promise = generator.operation?.({
             instance: this,
             operation,
             options: {
@@ -309,8 +302,8 @@ export class OperationGenerator<
 
     promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod))
 
-    parsers?.forEach((parser) => {
-      const promise = parser.operations?.({
+    generators?.forEach((generator) => {
+      const promise = generator.operations?.({
         instance: this,
         operations: operations.flat().filter(Boolean),
         operationsByMethod: this.operationsByMethod,
@@ -331,41 +324,41 @@ export class OperationGenerator<
   /**
    * Operation
    */
-  async operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async operation(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * GET
    */
-  async get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async get(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * POST
    */
-  async post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async post(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
   /**
    * PATCH
    */
-  async patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async patch(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * PUT
    */
-  async put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async put(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * DELETE
    */
-  async delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async delete(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 

package/src/SchemaGenerator.ts

@@ -1,4 +1,4 @@
-import { type FileMetaBase, Generator } from '@kubb/core'
+import { BaseGenerator, type FileMetaBase } from '@kubb/core'
 import transformers, { pascalCase } from '@kubb/core/transformers'
 import { getUniqueName } from '@kubb/core/utils'
 
@@ -13,7 +13,7 @@ import type * as KubbFile from '@kubb/fs/types'
 
 import type { Oas, OpenAPIV3, SchemaObject, contentType } from '@kubb/oas'
 import type { Schema, SchemaKeywordMapper } from './SchemaMapper.ts'
-import type { Parser } from './parser.tsx'
+import type { Generator } from './generator.tsx'
 import type { OperationSchema, Override, Refs } from './types.ts'
 
 export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
@@ -68,7 +68,7 @@ export class SchemaGenerator<
   TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
   // Collect the types of all referenced schemas, so we can export them later
   refs: Refs = {}
 
@@ -302,7 +302,7 @@ export class SchemaGenerator<
 
     if (additionalProperties) {
       additionalPropertiesSchemas =
-        additionalProperties === true
+        additionalProperties === true || !Object.keys(additionalProperties).length
           ? [{ keyword: this.#getUnknownReturn({ schema, name }) }]
           : this.parse({ schema: additionalProperties as SchemaObject, parentName: name })
     }
@@ -349,7 +349,7 @@ export class SchemaGenerator<
     const file = this.context.pluginManager.getFile({
       name: fileName,
       pluginKey: this.context.plugin.key,
-      extName: '.ts',
+      extname: '.ts',
     })
 
     ref = this.refs[$ref] = {
@@ -379,12 +379,6 @@ export class SchemaGenerator<
     const options = this.#getOptions({ schema: _schema, name })
     const unknownReturn = this.#getUnknownReturn({ schema: _schema, name })
     const { schema, version } = this.#getParsedSchemaObject(_schema)
-    const resolvedName = this.context.pluginManager.resolveName({
-      name: `${parentName || ''} ${name}`,
-      pluginKey: this.context.plugin.key,
-      type: 'type',
-    })
-
     if (!schema) {
       return [{ keyword: unknownReturn }]
     }
@@ -408,12 +402,16 @@ export class SchemaGenerator<
           keyword: schemaKeywords.default,
           args: transformers.stringify(schema.default),
         })
-      }
-      if (typeof schema.default === 'boolean') {
+      } else if (typeof schema.default === 'boolean') {
         baseItems.push({
           keyword: schemaKeywords.default,
           args: schema.default ?? false,
         })
+      } else {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: schema.default,
+        })
       }
     }
 
@@ -455,10 +453,16 @@ export class SchemaGenerator<
       baseItems.push({ keyword: schemaKeywords.readOnly })
     }
 
+    if (schema.writeOnly) {
+      baseItems.push({ keyword: schemaKeywords.writeOnly })
+    }
+
     if (isReference(schema)) {
       return [
         ...this.#getRefAlias(schema),
         nullable && { keyword: schemaKeywords.nullable },
+        schema.readOnly && { keyword: schemaKeywords.readOnly },
+        schema.writeOnly && { keyword: schemaKeywords.writeOnly },
         {
           keyword: schemaKeywords.schema,
           args: {
@@ -485,7 +489,20 @@ export class SchemaGenerator<
           }),
       }
       if (schemaWithoutOneOf.properties) {
-        return [...this.parse({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems]
+        const propertySchemas = this.parse({ schema: schemaWithoutOneOf, name, parentName })
+
+        return [
+          {
+            ...union,
+            args: union.args.map((arg) => {
+              return {
+                keyword: schemaKeywords.and,
+                args: [arg, ...propertySchemas],
+              }
+            }),
+          },
+          ...baseItems,
+        ]
       }
 
       return [union, ...baseItems]
@@ -620,6 +637,35 @@ export class SchemaGenerator<
         ]
       }
 
+      if (schema.type === 'boolean') {
+        // we cannot use z.enum when enum type is boolean
+        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum)) as unknown as SchemaKeywordMapper['enum']
+        return [
+          {
+            keyword: schemaKeywords.enum,
+            args: {
+              name: enumName,
+              typeName,
+              asConst: true,
+              items: enumNames?.args?.items
+                ? [...new Set(enumNames.args.items)].map(({ name, value }) => ({
+                    name,
+                    value,
+                    format: 'boolean',
+                  }))
+                : [...new Set(filteredValues)].map((value: string) => {
+                    return {
+                      name: value,
+                      value,
+                      format: 'boolean',
+                    }
+                  }),
+            },
+          },
+          ...baseItems.filter((item) => item.keyword !== schemaKeywords.matches),
+        ]
+      }
+
       if (extensionEnums.length > 0 && extensionEnums[0]) {
         return extensionEnums[0]
       }
@@ -810,7 +856,7 @@ export class SchemaGenerator<
         ].filter(Boolean)
       }
 
-      if (!['boolean', 'object', 'number', 'string', 'integer'].includes(schema.type)) {
+      if (!['boolean', 'object', 'number', 'string', 'integer', 'null'].includes(schema.type)) {
         this.context.pluginManager.logger.emit('warning', `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`)
       }
 
@@ -821,14 +867,20 @@ export class SchemaGenerator<
     return [{ keyword: unknownReturn }]
   }
 
-  async build(...parsers: Array<Parser<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
+    oas.resolveDiscriminators()
+
     const schemas = getSchemas({ oas, contentType, includes: include })
 
-    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
+    const promises = Object.entries(schemas).reduce((acc, [name, value]) => {
+      if (!value) {
+        return acc
+      }
+
       const options = this.#getOptions({ name })
-      const promiseOperation = this.schema.call(this, name, schema, {
+      const promiseOperation = this.schema.call(this, name, value, {
         ...this.options,
         ...options,
       })
@@ -837,11 +889,16 @@ export class SchemaGenerator<
         acc.push(promiseOperation)
       }
 
-      parsers?.forEach((parser) => {
-        const promise = parser.schema?.({
+      generators?.forEach((generator) => {
+        const tree = this.parse({ schema: value, name: name })
+
+        const promise = generator.schema?.({
           instance: this,
-          name,
-          schema,
+          schema: {
+            name,
+            value,
+            tree,
+          },
           options: {
             ...this.options,
             ...options,

package/src/SchemaMapper.ts

@@ -12,6 +12,7 @@ export type SchemaKeywordMapper = {
   strict: { keyword: 'strict' }
   url: { keyword: 'url' }
   readOnly: { keyword: 'readOnly' }
+  writeOnly: { keyword: 'writeOnly' }
   uuid: { keyword: 'uuid' }
   email: { keyword: 'email' }
   firstName: { keyword: 'firstName' }
@@ -34,8 +35,8 @@ export type SchemaKeywordMapper = {
       asConst: boolean
       items: Array<{
         name: string | number
-        format: 'string' | 'number'
-        value?: string | number
+        format: 'string' | 'number' | 'boolean'
+        value?: string | number | boolean
       }>
     }
   }
@@ -44,8 +45,8 @@ export type SchemaKeywordMapper = {
     keyword: 'const'
     args: {
       name: string | number
-      format: 'string' | 'number'
-      value?: string | number
+      format: 'string' | 'number' | 'boolean'
+      value?: string | number | boolean
     }
   }
   union: { keyword: 'union'; args: Schema[] }
@@ -107,6 +108,7 @@ export const schemaKeywords = {
   max: 'max',
   optional: 'optional',
   readOnly: 'readOnly',
+  writeOnly: 'writeOnly',
 
   // custom ones
   object: 'object',

package/src/components/Schema.tsx

@@ -1,15 +1,8 @@
-import { File, createContext, useApp, useFile } from '@kubb/react'
+import { createContext } from '@kubb/react'
 
-import { schemaKeywords } from '../SchemaMapper.ts'
-import { useSchema } from '../hooks/useSchema.ts'
-
-import type * as KubbFile from '@kubb/fs/types'
 import type { SchemaObject } from '@kubb/oas'
 import type { KubbNode } from '@kubb/react/types'
-import type { ReactNode } from 'react'
-import { SchemaGenerator } from '../SchemaGenerator.ts'
 import type { Schema as SchemaType } from '../SchemaMapper.ts'
-import type { PluginOas } from '../types.ts'
 
 export type SchemaContextProps = {
   name: string
@@ -33,95 +26,4 @@ export function Schema({ name, value, tree = [], children }: Props): KubbNode {
   return <SchemaContext.Provider value={{ name, schema: value, tree }}>{children}</SchemaContext.Provider>
 }
 
-type FileProps = {
-  isTypeOnly?: boolean
-  output: string | undefined
-  children?: KubbNode
-}
-
-Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode {
-  const { plugin, pluginManager, mode } = useApp<PluginOas>()
-  const { name } = useSchema()
-
-  if (mode === 'single') {
-    const baseName = `${pluginManager.resolveName({
-      name,
-      pluginKey: plugin.key,
-      type: 'file',
-    })}.ts` as const
-
-    const resolvedPath = pluginManager.resolvePath({
-      baseName: '',
-      pluginKey: plugin.key,
-    })
-
-    if (!resolvedPath) {
-      return null
-    }
-
-    return (
-      <File
-        baseName={baseName}
-        path={resolvedPath}
-        meta={{
-          pluginKey: plugin.key,
-        }}
-      >
-        {children}
-      </File>
-    )
-  }
-
-  const baseName = `${pluginManager.resolveName({
-    name,
-    pluginKey: plugin.key,
-    type: 'file',
-  })}.ts` as const
-  const resolvedPath = pluginManager.resolvePath({
-    baseName,
-    pluginKey: plugin.key,
-  })
-
-  if (!resolvedPath) {
-    return null
-  }
-
-  return (
-    <File
-      baseName={baseName}
-      path={resolvedPath}
-      meta={{
-        pluginKey: plugin.key,
-      }}
-    >
-      <Schema.Imports isTypeOnly={isTypeOnly} />
-      {children}
-    </File>
-  )
-}
-
-type SchemaImportsProps = {
-  isTypeOnly?: boolean
-}
-
-Schema.Imports = ({ isTypeOnly }: SchemaImportsProps): ReactNode => {
-  const { tree } = useSchema()
-  const { path: root } = useFile()
-
-  const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref)
-
-  return (
-    <>
-      {refs
-        ?.map((item, i) => {
-          if (!item.args.path) {
-            return undefined
-          }
-
-          return <File.Import key={i} root={root} name={[item.args.name]} path={item.args.path} isTypeOnly={isTypeOnly} />
-        })
-        .filter(Boolean)}
-    </>
-  )
-}
 Schema.Context = SchemaContext

package/src/{parser.tsx → generator.tsx}

@@ -1,12 +1,13 @@
 import type { PluginFactoryOptions } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
 import type { Operation, SchemaObject } from '@kubb/oas'
+import { Oas } from '@kubb/plugin-oas/components'
 import { App, createRoot } from '@kubb/react'
 import type { KubbNode } from '@kubb/react/types'
-import type * as KubbFile from '@kubb/fs/types'
-import type { OperationsByMethod } from './types.ts'
-import { Oas } from '@kubb/plugin-oas/components'
 import type { OperationGenerator } from './OperationGenerator.ts'
 import type { SchemaGenerator, SchemaGeneratorOptions } from './SchemaGenerator.ts'
+import type { Schema } from './SchemaMapper.ts'
+import type { OperationsByMethod } from './types.ts'
 
 type OperationsProps<TOptions extends PluginFactoryOptions> = {
   instance: Omit<OperationGenerator<TOptions>, 'build'>
@@ -23,32 +24,35 @@ type OperationProps<TOptions extends PluginFactoryOptions> = {
 
 type SchemaProps<TOptions extends PluginFactoryOptions> = {
   instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
-  name: string
-  schema: SchemaObject
+  schema: {
+    name: string
+    tree: Array<Schema>
+    value: SchemaObject
+  }
   options: TOptions['resolvedOptions']
 }
 
-export type ParserOptions<TOptions extends PluginFactoryOptions> = {
+export type GeneratorOptions<TOptions extends PluginFactoryOptions> = {
   name: string
-  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
-  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
-  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
+  operations?: (this: GeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
+  operation?: (this: GeneratorOptions<TOptions>, props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
+  schema?: (this: GeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
 }
 
-export type Parser<TOptions extends PluginFactoryOptions> = ParserOptions<TOptions>
+export type Generator<TOptions extends PluginFactoryOptions> = GeneratorOptions<TOptions>
 
-export function createParser<TOptions extends PluginFactoryOptions>(parseOptions: ParserOptions<TOptions>): Parser<TOptions> {
+export function createGenerator<TOptions extends PluginFactoryOptions>(parseOptions: GeneratorOptions<TOptions>): Generator<TOptions> {
   return parseOptions
 }
 
-export type ParserReactOptions<TOptions extends PluginFactoryOptions> = {
+export type ReactGeneratorOptions<TOptions extends PluginFactoryOptions> = {
   name: string
-  Operations?: (props: OperationsProps<TOptions>) => KubbNode
-  Operation?: (props: OperationProps<TOptions>) => KubbNode
-  Schema?: (props: SchemaProps<TOptions>) => KubbNode
+  Operations?: (this: ReactGeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => KubbNode
+  Operation?: (this: ReactGeneratorOptions<TOptions>, props: OperationProps<TOptions>) => KubbNode
+  Schema?: (this: ReactGeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => KubbNode
 }
 
-export function createReactParser<TOptions extends PluginFactoryOptions>(parseOptions: ParserReactOptions<TOptions>): Parser<TOptions> {
+export function createReactGenerator<TOptions extends PluginFactoryOptions>(parseOptions: ReactGeneratorOptions<TOptions>): Generator<TOptions> {
   return {
     ...parseOptions,
     async operations({ instance, options, operations, operationsByMethod }) {
@@ -61,10 +65,12 @@ export function createReactParser<TOptions extends PluginFactoryOptions>(parseOp
         logger: pluginManager.logger,
       })
 
+      const Component = parseOptions.Operations.bind(this)
+
       root.render(
         <App pluginManager={pluginManager} plugin={plugin} mode={mode}>
           <Oas oas={oas} operations={operations} generator={instance}>
-            <parseOptions.Operations operations={operations} instance={instance} operationsByMethod={operationsByMethod} options={options} />
+            <Component operations={operations} instance={instance} operationsByMethod={operationsByMethod} options={options} />
           </Oas>
         </App>,
       )
@@ -81,11 +87,13 @@ export function createReactParser<TOptions extends PluginFactoryOptions>(parseOp
         logger: pluginManager.logger,
       })
 
+      const Component = parseOptions.Operation.bind(this)
+
       root.render(
         <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
           <Oas oas={oas} operations={[operation]} generator={instance}>
             <Oas.Operation operation={operation}>
-              <parseOptions.Operation operation={operation} options={options} instance={instance} />
+              <Component operation={operation} options={options} instance={instance} />
             </Oas.Operation>
           </Oas>
         </App>,
@@ -93,7 +101,7 @@ export function createReactParser<TOptions extends PluginFactoryOptions>(parseOp
 
       return root.files
     },
-    async schema({ instance, schema, name, options }) {
+    async schema({ instance, schema, options }) {
       if (!parseOptions.Schema) {
         return []
       }
@@ -103,13 +111,13 @@ export function createReactParser<TOptions extends PluginFactoryOptions>(parseOp
         logger: pluginManager.logger,
       })
 
-      const tree = instance.parse({ schema, name })
+      const Component = parseOptions.Schema.bind(this)
 
       root.render(
         <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
           <Oas oas={oas}>
-            <Oas.Schema name={name} value={schema} tree={tree}>
-              <parseOptions.Schema schema={schema} options={options} instance={instance} name={name} />
+            <Oas.Schema name={schema.name} value={schema.value} tree={schema.tree}>
+              <Component schema={schema} options={options} instance={instance} />
             </Oas.Schema>
           </Oas>
         </App>,

package/src/generators/index.ts

@@ -0,0 +1 @@
+export { jsonGenerator } from './jsonGenerator.ts'

package/src/generators/jsonGenerator.ts

@@ -0,0 +1,32 @@
+import { camelCase } from '@kubb/core/transformers'
+import { createGenerator } from '../generator.tsx'
+import type { PluginOas } from '../types.ts'
+
+export const jsonGenerator = createGenerator<PluginOas>({
+  name: 'plugin-oas',
+  async schema({ schema, instance }) {
+    const { pluginManager, plugin } = instance.context
+    const file = pluginManager.getFile({
+      name: camelCase(schema.name),
+      extname: '.json',
+      mode: 'split',
+      pluginKey: plugin.key,
+    })
+
+    return [
+      {
+        ...file,
+        sources: [
+          {
+            name: camelCase(schema.name),
+            isExportable: false,
+            isIndexable: false,
+            value: JSON.stringify(schema.value),
+          },
+        ],
+        banner: plugin.options.output?.banner,
+        format: plugin.options.output?.footer,
+      },
+    ]
+  },
+})

package/src/hooks/index.ts

@@ -1,5 +1,7 @@
 export { useOas } from './useOas.ts'
 export { useOperation } from './useOperation.ts'
 export { useOperationManager } from './useOperationManager.ts'
+export type { SchemaNames } from './useOperationManager.ts'
 export { useOperations } from './useOperations.ts'
 export { useSchema } from './useSchema.ts'
+export { useSchemaManager } from './useSchemaManager.ts'