@kubb/plugin-ts 5.0.0-alpha.8 → 5.0.0-beta.10

package/src/generators/typeGenerator.tsx

@@ -1,467 +1,295 @@
-import { pascalCase } from '@internals/utils'
-import type { PluginDriver } from '@kubb/core'
-import { useMode, usePluginDriver } from '@kubb/core/hooks'
-import { safePrint } from '@kubb/fabric-core/parsers/typescript'
-import type { Operation } from '@kubb/oas'
-import { isKeyword, type OperationSchemas, type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
-import { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from '@kubb/plugin-oas/utils'
-import { File } from '@kubb/react-fabric'
-import ts from 'typescript'
-import { Type } from '../components'
-import * as factory from '../factory.ts'
-import { createUrlTemplateType, getUnknownType, keywordTypeNodes } from '../factory.ts'
-import { pluginTsName } from '../plugin.ts'
+import { ast, defineGenerator } from '@kubb/core'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { Type } from '../components/Type.tsx'
+import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
+import { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types'
+import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
+
+function getContentTypeSuffix(contentType: string): string {
+  const baseType = contentType.split(';')[0]!.trim()
+  if (baseType === 'application/json') return 'Json'
+  if (baseType === 'multipart/form-data') return 'FormData'
+  if (baseType === 'application/x-www-form-urlencoded') return 'FormUrlEncoded'
+  const subtype = baseType.split('/').pop() ?? baseType
+  const parts = subtype.split(/[^a-zA-Z0-9]+/).filter(Boolean)
+  if (parts.length === 0) return 'Unknown'
+  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
+}
 
-function printCombinedSchema({ name, schemas, driver }: { name: string; schemas: OperationSchemas; driver: PluginDriver }): string {
-  const properties: Record<string, ts.TypeNode> = {}
-
-  if (schemas.response) {
-    properties['response'] = factory.createUnionDeclaration({
-      nodes: schemas.responses.map((res) => {
-        const identifier = driver.resolveName({
-          name: res.name,
-          pluginName: pluginTsName,
-          type: 'function',
-        })
-
-        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-      }),
-    })!
-  }
-
-  if (schemas.request) {
-    const identifier = driver.resolveName({
-      name: schemas.request.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['request'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.pathParams) {
-    const identifier = driver.resolveName({
-      name: schemas.pathParams.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['pathParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.queryParams) {
-    const identifier = driver.resolveName({
-      name: schemas.queryParams.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['queryParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.headerParams) {
-    const identifier = driver.resolveName({
-      name: schemas.headerParams.name,
-      pluginName: pluginTsName,
-      type: 'function',
-    })
-    properties['headerParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.errors) {
-    properties['errors'] = factory.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        const identifier = driver.resolveName({
-          name: error.name,
-          pluginName: pluginTsName,
-          type: 'function',
-        })
-
-        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-      }),
-    })!
+function getPerContentTypeName(dataName: string, suffix: string): string {
+  if (dataName.endsWith('Data')) {
+    return suffix.endsWith('Data') ? dataName.slice(0, -4) + suffix : `${dataName.slice(0, -4)}${suffix}Data`
   }
-
-  const namespaceNode = factory.createTypeAliasDeclaration({
-    name,
-    type: factory.createTypeLiteralNode(
-      Object.keys(properties)
-        .map((key) => {
-          const type = properties[key]
-          if (!type) {
-            return undefined
-          }
-
-          return factory.createPropertySignature({
-            name: pascalCase(key),
-            type,
-          })
-        })
-        .filter(Boolean),
-    ),
-    modifiers: [factory.modifiers.export],
-  })
-
-  return safePrint(namespaceNode)
+  return dataName + suffix
 }
 
-function printRequestSchema({
-  baseName,
-  operation,
-  schemas,
-  driver,
-}: {
-  baseName: string
-  operation: Operation
-  schemas: OperationSchemas
-  driver: PluginDriver
-}): string {
-  const name = driver.resolveName({
-    name: `${baseName} Request`,
-    pluginName: pluginTsName,
-    type: 'type',
-  })
-
-  const results: string[] = []
-
-  // Generate DataRequest type
-  const dataRequestProperties: ts.PropertySignature[] = []
-
-  if (schemas.request) {
-    const identifier = driver.resolveName({
-      name: schemas.request.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'data',
-        questionToken: true,
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'data',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
+export const typeGenerator = defineGenerator<PluginTs>({
+  name: 'typescript',
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
+    const { adapter, config, resolver, root } = ctx
 
-  // Add pathParams property
-  if (schemas.pathParams) {
-    const identifier = driver.resolveName({
-      name: schemas.pathParams.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'pathParams',
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'pathParams',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
+    if (!node.name) {
+      return
+    }
+    const mode = ctx.getMode(output)
+    // Build a set of schema names that are enums so the ref handler and getImports
+    // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
+    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
+
+    function resolveImportName(schemaName: string): string {
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
+        return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
+      }
+      return resolver.resolveTypeName(schemaName)
+    }
 
-  // Add queryParams property
-  if (schemas.queryParams) {
-    const identifier = driver.resolveName({
-      name: schemas.queryParams.name,
-      pluginName: pluginTsName,
-      type: 'type',
+    const imports = adapter.getImports(node, (schemaName) => ({
+      name: resolveImportName(schemaName),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+    }))
+
+    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
+
+    const meta = {
+      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
+    } as const
+
+    const schemaPrinter = printerTs({
+      optionalType,
+      arrayType,
+      enumType,
+      enumTypeSuffix,
+      name: meta.name,
+      syntaxType,
+      description: node.description,
+      resolver,
+      enumSchemaNames,
+      nodes: printer?.nodes,
     })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'queryParams',
-        questionToken: true,
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'queryParams',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
-    )
-  }
 
-  // Add headerParams property
-  if (schemas.headerParams) {
-    const identifier = driver.resolveName({
-      name: schemas.headerParams.name,
-      pluginName: pluginTsName,
-      type: 'type',
-    })
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'headerParams',
-        questionToken: true,
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
-      }),
-    )
-  } else {
-    dataRequestProperties.push(
-      factory.createPropertySignature({
-        name: 'headerParams',
-        questionToken: true,
-        type: keywordTypeNodes.never,
-      }),
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+      >
+        {mode === 'split' &&
+          imports.map((imp) => (
+            <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
+          ))}
+        <Type
+          name={meta.name}
+          node={node}
+          enumType={enumType}
+          enumTypeSuffix={enumTypeSuffix}
+          enumKeyCasing={enumKeyCasing}
+          resolver={resolver}
+          printer={schemaPrinter}
+        />
+      </File>
     )
-  }
+  },
+  operation(node, ctx) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options
+    const { adapter, config, resolver, root } = ctx
 
-  // Add url property with template literal type
-  dataRequestProperties.push(
-    factory.createPropertySignature({
-      name: 'url',
-      type: createUrlTemplateType(operation.path),
-    }),
-  )
+    const mode = ctx.getMode(output)
 
-  const dataRequestNode = factory.createTypeAliasDeclaration({
-    name,
-    type: factory.createTypeLiteralNode(dataRequestProperties),
-    modifiers: [factory.modifiers.export],
-  })
+    const params = ast.caseParams(node.parameters, paramsCasing)
 
-  results.push(safePrint(dataRequestNode))
+    const meta = {
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+    } as const
 
-  return results.join('\n\n')
-}
+    // Build a set of schema names that are enums so the ref handler and getImports
+    // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
+    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
 
-function printResponseSchema({
-  baseName,
-  schemas,
-  driver,
-  unknownType,
-}: {
-  baseName: string
-  schemas: OperationSchemas
-  driver: PluginDriver
-  unknownType: PluginTs['resolvedOptions']['unknownType']
-}): string {
-  const results: string[] = []
-
-  const name = driver.resolveName({
-    name: `${baseName} ResponseData`,
-    pluginName: pluginTsName,
-    type: 'type',
-  })
-
-  // Generate Responses type (mapping status codes to response types)
-  if (schemas.responses && schemas.responses.length > 0) {
-    const responsesProperties: ts.PropertySignature[] = schemas.responses.map((res) => {
-      const identifier = driver.resolveName({
-        name: res.name,
-        pluginName: pluginTsName,
-        type: 'type',
-      })
+    function resolveImportName(schemaName: string): string {
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
+        return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
+      }
+      return resolver.resolveTypeName(schemaName)
+    }
 
-      return factory.createPropertySignature({
-        name: res.statusCode?.toString() ?? 'default',
-        type: factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined),
+    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+      if (!schema) return null
+
+      const imports = adapter.getImports(schema, (schemaName) => ({
+        name: resolveImportName(schemaName),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      }))
+
+      const schemaPrinter = printerTs({
+        optionalType,
+        arrayType,
+        enumType,
+        enumTypeSuffix,
+        name,
+        syntaxType,
+        description: schema.description,
+        keysToOmit,
+        resolver,
+        enumSchemaNames,
+        nodes: printer?.nodes,
       })
-    })
-
-    const responsesNode = factory.createTypeAliasDeclaration({
-      name: `${baseName}Responses`,
-      type: factory.createTypeLiteralNode(responsesProperties),
-      modifiers: [factory.modifiers.export],
-    })
-
-    results.push(safePrint(responsesNode))
-
-    // Generate Response type (union via indexed access)
-    const responseNode = factory.createTypeAliasDeclaration({
-      name,
-      type: factory.createIndexedAccessTypeNode(
-        factory.createTypeReferenceNode(factory.createIdentifier(`${baseName}Responses`), undefined),
-        factory.createTypeOperatorNode(
-          ts.SyntaxKind.KeyOfKeyword,
-          factory.createTypeReferenceNode(factory.createIdentifier(`${baseName}Responses`), undefined),
-        ),
-      ),
-      modifiers: [factory.modifiers.export],
-    })
-
-    results.push(safePrint(responseNode))
-  } else {
-    const responseNode = factory.createTypeAliasDeclaration({
-      name,
-      modifiers: [factory.modifiers.export],
-      type: getUnknownType(unknownType),
-    })
-
-    results.push(safePrint(responseNode))
-  }
-
-  return results.join('\n\n')
-}
-
-export const typeGenerator = createReactGenerator<PluginTs>({
-  name: 'typescript',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options,
-      options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing },
-    } = plugin
-
-    const mode = useMode()
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator)
-    const schemaManager = useSchemaManager()
-
-    const name = getName(operation, { type: 'type', pluginName: pluginTsName })
-
-    const file = getFile(operation)
-    const schemas = getSchemas(operation)
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      events: generator.context.events,
-      plugin,
-      driver,
-      mode,
-      override: options.override,
-    })
-
-    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
-      .flat()
-      .filter(Boolean)
-
-    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }: OperationSchemaType) => {
-      // Apply paramsCasing transformation to pathParams, queryParams, and headerParams (not response)
-      const shouldTransform = paramsCasing && isParameterSchema(name)
-      const transformedSchema = shouldTransform ? applyParamsCasing(schema, paramsCasing) : schema
-
-      const tree = schemaGenerator.parse({ schema: transformedSchema, name, parentName: null })
-      const imports = getImports(tree)
-      const group = options.operation ? getGroup(options.operation) : undefined
-
-      const type = {
-        name: schemaManager.getName(name, { type: 'type' }),
-        typedName: schemaManager.getName(name, { type: 'type' }),
-        file: schemaManager.getFile(options.operationName || name, { group }),
-      }
 
       return (
         <>
           {mode === 'split' &&
             imports.map((imp) => (
-              <File.Import key={[name, imp.name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />
+              <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
             ))}
           <Type
-            name={type.name}
-            typedName={type.typedName}
-            description={description}
-            tree={tree}
-            schema={transformedSchema}
+            name={name}
+            node={schema}
             enumType={enumType}
+            enumTypeSuffix={enumTypeSuffix}
             enumKeyCasing={enumKeyCasing}
-            optionalType={optionalType}
-            arrayType={arrayType}
-            keysToOmit={keysToOmit}
-            syntaxType={syntaxType}
+            resolver={resolver}
+            printer={schemaPrinter}
           />
         </>
       )
     }
 
-    const responseName = schemaManager.getName(schemas.response.name, {
-      type: 'type',
-    })
+    const paramTypes = params.map((param) =>
+      renderSchemaType({
+        schema: param.schema,
+        name: resolver.resolveParamName(node, param),
+      }),
+    )
+
+    const requestBodyContent = node.requestBody?.content ?? []
+
+    function buildRequestType() {
+      if (requestBodyContent.length === 0) return null
+      if (requestBodyContent.length === 1) {
+        const entry = requestBodyContent[0]!
+        if (!entry.schema) return null
+        return renderSchemaType({
+          schema: {
+            ...entry.schema,
+            description: node.requestBody!.description ?? entry.schema.description,
+          },
+          name: resolver.resolveDataName(node),
+          keysToOmit: entry.keysToOmit,
+        })
+      }
+      // Multiple content types — generate individual types + union alias
+      const dataName = resolver.resolveDataName(node)
+      const usedNames = new Set<string>()
+      const individualItems = requestBodyContent
+        .filter((entry) => entry.schema)
+        .map((entry) => {
+          const baseSuffix = getContentTypeSuffix(entry.contentType)
+          let individualName = getPerContentTypeName(dataName, baseSuffix)
+          let counter = 2
+          while (usedNames.has(individualName)) {
+            individualName = getPerContentTypeName(dataName, `${baseSuffix}${counter++}`)
+          }
+          usedNames.add(individualName)
+          return {
+            name: individualName,
+            rendered: renderSchemaType({
+              schema: {
+                ...entry.schema!,
+                description: node.requestBody!.description ?? entry.schema!.description,
+              },
+              name: individualName,
+              keysToOmit: entry.keysToOmit,
+            }),
+          }
+        })
+      const unionSchema = ast.createSchema({
+        type: 'union',
+        members: individualItems.map((item) => ast.createSchema({ type: 'ref', name: item.name })),
+      })
+      const unionType = renderSchemaType({ schema: unionSchema, name: dataName })
+      return (
+        <>
+          {individualItems.map((item) => item.rendered)}
+          {unionType}
+        </>
+      )
+    }
 
-    const combinedSchemaName = operation.method === 'get' ? `${name}Query` : `${name}Mutation`
+    const requestType = buildRequestType()
 
-    return (
-      <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: driver.config })}
-        footer={getFooter({ oas, output: plugin.options.output })}
-      >
-        {operationSchemas.map(mapOperationSchema)}
-
-        {generator.context.UNSTABLE_NAMING ? (
-          <>
-            <File.Source name={`${name}Request`} isExportable isIndexable isTypeOnly>
-              {printRequestSchema({ baseName: name, operation, schemas, driver })}
-            </File.Source>
-            <File.Source name={responseName} isExportable isIndexable isTypeOnly>
-              {printResponseSchema({ baseName: name, schemas, driver, unknownType })}
-            </File.Source>
-          </>
-        ) : (
-          <File.Source name={combinedSchemaName} isExportable isIndexable isTypeOnly>
-            {printCombinedSchema({ name: combinedSchemaName, schemas, driver })}
-          </File.Source>
-        )}
-      </File>
+    const responseTypes = node.responses.map((res) =>
+      renderSchemaType({
+        schema: res.schema,
+        name: resolver.resolveResponseStatusName(node, res.statusCode),
+        keysToOmit: res.keysToOmit,
+      }),
     )
-  },
-  Schema({ schema, plugin }) {
-    const {
-      options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output },
-    } = plugin
-    const mode = useMode()
 
-    const oas = useOas()
-    const driver = usePluginDriver()
+    const dataType = renderSchemaType({
+      schema: buildData({ ...node, parameters: params }, { resolver }),
+      name: resolver.resolveRequestConfigName(node),
+    })
+
+    const responsesType = renderSchemaType({
+      schema: buildResponses(node, { resolver }),
+      name: resolver.resolveResponsesName(node),
+    })
 
-    const { getName, getFile } = useSchemaManager()
-    const imports = getImports(schema.tree)
-    const schemaFromTree = schema.tree.find((item) => item.keyword === schemaKeywords.schema)
+    function buildResponseType() {
+      if (!node.responses.some((res) => res.schema)) {
+        return null
+      }
 
-    let typedName = getName(schema.name, { type: 'type' })
+      const responseName = resolver.resolveResponseName(node)
+
+      const responsesWithSchema = node.responses.filter((res) => res.schema)
+      const importedNames = new Set(
+        responsesWithSchema.flatMap((res) =>
+          res.schema
+            ? adapter
+                .getImports(res.schema, (schemaName) => ({
+                  name: resolveImportName(schemaName),
+                  path: '',
+                }))
+                .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
+            : [],
+        ),
+      )
 
-    if (['asConst', 'asPascalConst'].includes(enumType) && schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.enum)) {
-      typedName = typedName += 'Key' //Suffix for avoiding collisions (https://github.com/kubb-labs/kubb/issues/1873)
-    }
+      if (importedNames.has(responseName)) {
+        return null
+      }
 
-    const type = {
-      name: getName(schema.name, { type: 'function' }),
-      typedName,
-      file: getFile(schema.name),
+      return renderSchemaType({
+        schema: {
+          ...buildResponseUnion(node, { resolver })!,
+          description: 'Union of all possible responses',
+        },
+        name: responseName,
+      })
     }
 
+    const responseType = buildResponseType()
+
     return (
       <File
-        baseName={type.file.baseName}
-        path={type.file.path}
-        meta={type.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        {mode === 'split' &&
-          imports.map((imp) => (
-            <File.Import key={[schema.name, imp.path, imp.isTypeOnly].join('-')} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />
-          ))}
-        <Type
-          name={type.name}
-          typedName={type.typedName}
-          description={schema.value.description}
-          tree={schema.tree}
-          schema={schema.value}
-          enumType={enumType}
-          enumKeyCasing={enumKeyCasing}
-          optionalType={optionalType}
-          arrayType={arrayType}
-          syntaxType={syntaxType}
-        />
+        {paramTypes}
+        {responseTypes}
+        {requestType}
+        {dataType}
+        {responsesType}
+        {responseType}
       </File>
     )
   },