@kubb/swagger-ts 2.11.0 → 2.12.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as _kubb_core from '@kubb/core';
 import { KubbFile, ResolveNameParams, Plugin, PluginFactoryOptions } from '@kubb/core';
 import { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger';
-export { i as Oas } from './index-BKDH3fXc.cjs';
+export { i as Oas } from './index-_MgWTBjd.cjs';
 import 'hotscript';
 import 'ts-toolbelt';
 import '@kubb/swagger/oas';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _kubb_core from '@kubb/core';
 import { KubbFile, ResolveNameParams, Plugin, PluginFactoryOptions } from '@kubb/core';
 import { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger';
-export { i as Oas } from './index-BKDH3fXc.js';
+export { i as Oas } from './index-_MgWTBjd.js';
 import 'hotscript';
 import 'ts-toolbelt';
 import '@kubb/swagger/oas';

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   pluginKey,
   pluginName,
   src_default
-} from "./chunk-QIZFD754.js";
+} from "./chunk-ZNLTJZHN.js";
 export {
   src_default as default,
   definePlugin,

package/dist/oas.d.cts

@@ -1,4 +1,4 @@
-export { I as Infer, M as MethodMap, a as Model, P as PathMap, R as RequestParams, b as Response, S as StatusMap } from './index-BKDH3fXc.cjs';
+export { I as Infer, M as MethodMap, a as Model, P as PathMap, R as RequestParams, b as Response, S as StatusMap } from './index-_MgWTBjd.cjs';
 import 'hotscript';
 import 'ts-toolbelt';
 import '@kubb/swagger/oas';

package/dist/oas.d.ts

@@ -1,4 +1,4 @@
-export { I as Infer, M as MethodMap, a as Model, P as PathMap, R as RequestParams, b as Response, S as StatusMap } from './index-BKDH3fXc.js';
+export { I as Infer, M as MethodMap, a as Model, P as PathMap, R as RequestParams, b as Response, S as StatusMap } from './index-_MgWTBjd.js';
 import 'hotscript';
 import 'ts-toolbelt';
 import '@kubb/swagger/oas';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/swagger-ts",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "Generator swagger-ts",
   "keywords": [
     "typescript",
@@ -59,16 +59,17 @@
     "hotscript": "^1.0.13",
     "json-schema-to-ts": "^3.0.1",
     "ts-toolbelt": "^9.6.0",
-    "@kubb/core": "2.11.0",
-    "@kubb/parser": "2.11.0",
-    "@kubb/react": "2.11.0",
-    "@kubb/swagger": "2.11.0",
-    "@kubb/types": "2.11.0"
+    "@kubb/core": "2.12.0",
+    "@kubb/parser": "2.12.0",
+    "@kubb/react": "2.12.0",
+    "@kubb/swagger": "2.12.0",
+    "@kubb/types": "2.12.0"
   },
   "devDependencies": {
-    "@types/react": "^18.2.69",
+    "@types/react": "^18.2.73",
     "eslint": "^8.57.0",
-    "expect-type": "^0.17.3",
+    "expect-type": "^0.19.0",
+    "prettier": "^3.2.5",
     "react": "^18.2.0",
     "tsup": "^8.0.2",
     "@kubb/eslint-config": "1.1.8",
@@ -76,7 +77,7 @@
     "@kubb/tsup-config": "1.1.8"
   },
   "peerDependencies": {
-    "@kubb/react": "2.11.0"
+    "@kubb/react": "2.12.0"
   },
   "packageManager": "pnpm@8.3.0",
   "engines": {

package/src/OperationGenerator.tsx

@@ -14,7 +14,9 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
   async all(operations: Operation[]): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin } = this.context
 
-    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({
+      logger: pluginManager.logger,
+    })
 
     root.render(
       <Oas oas={oas} operations={operations} getOperationSchemas={(...props) => this.getSchemas(...props)}>
@@ -26,13 +28,12 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     return root.files
   }
 
-  async operation(
-    operation: Operation,
-    options: PluginOptions['resolvedOptions'],
-  ): OperationMethodResult<FileMeta> {
+  async operation(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
     const { oas, pluginManager, plugin, mode } = this.context
 
-    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({
+      logger: pluginManager.logger,
+    })
     root.render(
       <Oas oas={oas} operations={[operation]} getOperationSchemas={(...props) => this.getSchemas(...props)}>
         <Oas.Operation operation={operation}>

package/src/SchemaGenerator.tsx

@@ -15,7 +15,9 @@ export class SchemaGenerator extends Generator<PluginOptions['resolvedOptions'],
   async schema(name: string, object: SchemaObject): SchemaMethodResult<FileMeta> {
     const { oas, pluginManager, mode, plugin, output } = this.context
 
-    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({
+      logger: pluginManager.logger,
+    })
 
     root.render(
       <Oas oas={oas}>
@@ -29,14 +31,19 @@ export class SchemaGenerator extends Generator<PluginOptions['resolvedOptions'],
     return root.files
   }
   // TODO convert to a react component called `Schema.Parser` with props parser as part of the SchemaContext
-  getSource(name: string, schemas: SchemaType[], {
-    keysToOmit,
-    description,
-  }: SchemaGeneratorBuildOptions = {}): string[] {
+  getSource(name: string, schemas: SchemaType[], { keysToOmit, description }: SchemaGeneratorBuildOptions = {}): string[] {
     const texts: string[] = []
 
-    const resolvedName = this.context.pluginManager.resolveName({ name, pluginKey, type: 'function' })
-    const resvoledTypeName = this.context.pluginManager.resolveName({ name, pluginKey: swaggerTypeScriptPluginKey, type: 'type' })
+    const resolvedName = this.context.pluginManager.resolveName({
+      name,
+      pluginKey,
+      type: 'function',
+    })
+    const resvoledTypeName = this.context.pluginManager.resolveName({
+      name,
+      pluginKey: swaggerTypeScriptPluginKey,
+      type: 'type',
+    })
 
     const typeOutput = typeParser(schemas, {
       name: resolvedName,

package/src/components/OasType.tsx

@@ -1,5 +1,4 @@
-import { Editor, File, Type, usePlugin } from '@kubb/react'
-import { useGetFile } from '@kubb/react'
+import { Editor, File, Type, usePlugin, usePluginManager } from '@kubb/react'
 import { useOas } from '@kubb/swagger/hooks'
 
 import type { OasTypes } from '@kubb/swagger/oas'
@@ -15,11 +14,7 @@ type TemplateProps = {
   api: OasTypes.OASDocument
 }
 
-function Template({
-  name,
-  typeName,
-  api,
-}: TemplateProps): ReactNode {
+function Template({ name, typeName, api }: TemplateProps): ReactNode {
   return (
     <>
       {`export const ${name} = ${JSON.stringify(api, undefined, 2)} as const`}
@@ -42,11 +37,7 @@ type Props = {
   Template?: React.ComponentType<React.ComponentProps<typeof Template>>
 }
 
-export function OasType({
-  name,
-  typeName,
-  Template = defaultTemplates.default,
-}: Props): ReactNode {
+export function OasType({ name, typeName, Template = defaultTemplates.default }: Props): ReactNode {
   const oas = useOas()
 
   return <Template name={name} typeName={typeName} api={oas.api} />
@@ -61,19 +52,16 @@ type FileProps = {
   templates?: typeof defaultTemplates
 }
 
-OasType.File = function({ name, typeName, templates = defaultTemplates }: FileProps): ReactNode {
+OasType.File = function ({ name, typeName, templates = defaultTemplates }: FileProps): ReactNode {
   const { key: pluginKey } = usePlugin<PluginOptions>()
-  const file = useGetFile({ name, extName: '.ts', pluginKey })
+  const pluginManager = usePluginManager()
+  const file = pluginManager.getFile({ name, extName: '.ts', pluginKey })
 
   const Template = templates.default
 
   return (
     <Editor language="typescript">
-      <File<FileMeta>
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-      >
+      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
         <File.Import name={['Infer']} path="@kubb/swagger-ts/oas" isTypeOnly />
         <File.Source>
           <OasType Template={Template} name={name} typeName={typeName} />

package/src/components/OperationSchema.tsx

@@ -5,7 +5,7 @@ import { print } from '@kubb/parser'
 import * as factory from '@kubb/parser/factory'
 import { Editor, File, usePlugin, usePluginManager } from '@kubb/react'
 import { Oas, Schema } from '@kubb/swagger/components'
-import { useGetOperationFile, useOas, useOperation, useOperationName, useOperationSchemas } from '@kubb/swagger/hooks'
+import { useOas, useOperation, useOperationManager } from '@kubb/swagger/hooks'
 
 import { SchemaGenerator } from '../SchemaGenerator.tsx'
 
@@ -21,47 +21,29 @@ type Props = {}
 
 function printCombinedSchema(name: string, operation: Operation, schemas: OperationSchemas): string {
   const properties: Record<string, ts.TypeNode> = {
-    'response': factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.response.name),
-      undefined,
-    ),
+    response: factory.createTypeReferenceNode(factory.createIdentifier(schemas.response.name), undefined),
   }
 
   if (schemas.request) {
-    properties['request'] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.request.name),
-      undefined,
-    )
+    properties['request'] = factory.createTypeReferenceNode(factory.createIdentifier(schemas.request.name), undefined)
   }
 
   if (schemas.pathParams) {
-    properties['pathParams'] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.pathParams.name),
-      undefined,
-    )
+    properties['pathParams'] = factory.createTypeReferenceNode(factory.createIdentifier(schemas.pathParams.name), undefined)
   }
 
   if (schemas.queryParams) {
-    properties['queryParams'] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.queryParams.name),
-      undefined,
-    )
+    properties['queryParams'] = factory.createTypeReferenceNode(factory.createIdentifier(schemas.queryParams.name), undefined)
   }
 
   if (schemas.headerParams) {
-    properties['headerParams'] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.headerParams.name),
-      undefined,
-    )
+    properties['headerParams'] = factory.createTypeReferenceNode(factory.createIdentifier(schemas.headerParams.name), undefined)
   }
 
   if (schemas.errors) {
     properties['errors'] = factory.createUnionDeclaration({
-      nodes: schemas.errors.map(error => {
-        return factory.createTypeReferenceNode(
-          factory.createIdentifier(error.name),
-          undefined,
-        )
+      nodes: schemas.errors.map((error) => {
+        return factory.createTypeReferenceNode(factory.createIdentifier(error.name), undefined)
       }),
     })!
   }
@@ -69,19 +51,19 @@ function printCombinedSchema(name: string, operation: Operation, schemas: Operat
   const namespaceNode = factory.createTypeAliasDeclaration({
     name: operation.method === 'get' ? `${name}Query` : `${name}Mutation`,
     type: factory.createTypeLiteralNode(
-      Object.keys(properties).map(key => {
-        const type = properties[key]
-        if (!type) {
-          return undefined
-        }
-
-        return factory.createPropertySignature(
-          {
+      Object.keys(properties)
+        .map((key) => {
+          const type = properties[key]
+          if (!type) {
+            return undefined
+          }
+
+          return factory.createPropertySignature({
             name: transformers.pascalCase(key),
             type,
-          },
-        )
-      }).filter(Boolean),
+          })
+        })
+        .filter(Boolean),
     ),
     modifiers: [factory.modifiers.export],
   })
@@ -90,42 +72,36 @@ function printCombinedSchema(name: string, operation: Operation, schemas: Operat
 }
 
 export function OperationSchema({}: Props): ReactNode {
-  return (
-    <>
-    </>
-  )
+  return <></>
 }
 
 type FileProps = {
   mode: KubbFile.Mode | undefined
 }
 
-OperationSchema.File = function({ mode = 'directory' }: FileProps): ReactNode {
+OperationSchema.File = function ({ mode = 'directory' }: FileProps): ReactNode {
   const plugin = usePlugin<PluginOptions>()
 
   const pluginManager = usePluginManager()
   const oas = useOas()
-  const schemas = useOperationSchemas()
-  const file = useGetOperationFile()
-  const factoryName = useOperationName({ type: 'type' })
+  const { getSchemas, getFile, getName } = useOperationManager()
   const operation = useOperation()
 
-  const generator = new SchemaGenerator(plugin.options, { oas, plugin, pluginManager })
+  const file = getFile(operation)
+  const schemas = getSchemas(operation)
+  const factoryName = getName(operation, { type: 'type' })
+  const generator = new SchemaGenerator(plugin.options, {
+    oas,
+    plugin,
+    pluginManager,
+  })
 
-  const items = [
-    schemas.pathParams,
-    schemas.queryParams,
-    schemas.headerParams,
-    schemas.statusCodes,
-    schemas.request,
-    schemas.response,
-  ].flat().filter(Boolean)
+  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean)
 
   const mapItem = ({ name, schema: object, ...options }: OperationSchemaType, i: number) => {
     return (
       <Oas.Schema key={i} generator={generator} name={name} object={object}>
-        {mode === 'directory'
-          && <Schema.Imports isTypeOnly />}
+        {mode === 'directory' && <Schema.Imports isTypeOnly />}
         <File.Source>
           <Schema.Source options={options} />
         </File.Source>
@@ -135,16 +111,10 @@ OperationSchema.File = function({ mode = 'directory' }: FileProps): ReactNode {
 
   return (
     <Editor language="typescript">
-      <File<FileMeta>
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-      >
+      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
         {items.map(mapItem)}
 
-        <File.Source>
-          {printCombinedSchema(factoryName, operation, schemas)}
-        </File.Source>
+        <File.Source>{printCombinedSchema(factoryName, operation, schemas)}</File.Source>
       </File>
     </Editor>
   )

package/src/oas/infer.ts

@@ -14,41 +14,35 @@ type Checks = {
   }
 }
 
-type FixAdditionalPropertiesForAllOf<T> = T extends Checks['AllOFf'] ? Omit<T, 'allOf'> & {
-    allOf: Call<Tuples.Map<Objects.Omit<'additionalProperties'>>, T['allOf']>
-  }
+type FixAdditionalPropertiesForAllOf<T> = T extends Checks['AllOFf']
+  ? Omit<T, 'allOf'> & {
+      allOf: Call<Tuples.Map<Objects.Omit<'additionalProperties'>>, T['allOf']>
+    }
   : T
 
-type FixMissingAdditionalProperties<T> = T extends Checks['Object'] ? Omit<T, 'additionalProperties'> & { additionalProperties: false }
-  : T
+type FixMissingAdditionalProperties<T> = T extends Checks['Object'] ? Omit<T, 'additionalProperties'> & { additionalProperties: false } : T
 type FixMissingTypeObject<T> = T extends Checks['Properties'] ? T & { type: 'object' } : T
 
-type FixExtraRequiredFields<T> = T extends Checks['PropertiesRequired'] ? Omit<T, 'required'> & {
-    required: Call<Tuples.Filter<Booleans.Extends<keyof T['properties']>>, T['required']>
-  }
+type FixExtraRequiredFields<T> = T extends Checks['PropertiesRequired']
+  ? Omit<T, 'required'> & {
+      required: Call<Tuples.Filter<Booleans.Extends<keyof T['properties']>>, T['required']>
+    }
   : T
 
 // Later suggest using json-machete
-type FixJSONSchema<T> = FixAdditionalPropertiesForAllOf<
-  FixMissingAdditionalProperties<FixMissingTypeObject<FixExtraRequiredFields<T>>>
->
+type FixJSONSchema<T> = FixAdditionalPropertiesForAllOf<FixMissingAdditionalProperties<FixMissingTypeObject<FixExtraRequiredFields<T>>>>
 
-type Mutable<Type> = FixJSONSchema<
-  {
-    -readonly [Key in keyof Type]: Mutable<Type[Key]>
-  }
->
+type Mutable<Type> = FixJSONSchema<{
+  -readonly [Key in keyof Type]: Mutable<Type[Key]>
+}>
 
-type RefToPath<T extends string> = T extends `#/${infer Ref}` ? Call<Strings.Split<'/'>, Ref>
-  : never
+type RefToPath<T extends string> = T extends `#/${infer Ref}` ? Call<Strings.Split<'/'>, Ref> : never
 
 type ResolveRef<TObj, TRef extends string> = {
   $id: TRef
 } & Object.Path<TObj, RefToPath<TRef>>
 
-type ResolveRefInObj<T, TBase> = T extends { $ref: infer Ref } ? Ref extends string ? ResolveRef<TBase, Ref>
-  : T
-  : T
+type ResolveRefInObj<T, TBase> = T extends { $ref: infer Ref } ? (Ref extends string ? ResolveRef<TBase, Ref> : T) : T
 
 type ResolveRefsInObj<T, TBase = T> = {
   [K in keyof T]: ResolveRefsInObj<ResolveRefInObj<T[K], TBase>, TBase>

package/src/oas/mappers.ts

@@ -1,10 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import type { OasTypes } from '@kubb/swagger/oas'
 import type { Fn, Pipe, Tuples } from 'hotscript'
-import type {
-  FromSchema,
-  JSONSchema,
-} from 'json-schema-to-ts'
+import type { FromSchema, JSONSchema } from 'json-schema-to-ts'
 
 type Checks<TParamType = never> = {
   Required: { required: true }
@@ -26,67 +23,54 @@ interface ParamPropMap {
   header: 'headers'
 }
 
-type JSONSchemaTypeName =
-  | 'string'
-  | 'number'
-  | 'integer'
-  | 'boolean'
-  | 'object'
-  | 'array'
-  | 'null'
+type JSONSchemaTypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null'
 
 type ParamObj<
   TParameter extends {
     name: string
   },
-> = TParameter extends Checks['Required'] ? {
-    [TName in TParameter['name']]: TParameter extends Checks['Schemas'] ? FromSchema<TParameter['schema']>
-      : TParameter extends Checks['Enum'] ? FromSchema<{
-          type: TParameter['type']
-          enum: TParameter['enum']
-        }>
-      : unknown
-  }
+> = TParameter extends Checks['Required']
+  ? {
+      [TName in TParameter['name']]: TParameter extends Checks['Schemas']
+        ? FromSchema<TParameter['schema']>
+        : TParameter extends Checks['Enum']
+          ? FromSchema<{
+              type: TParameter['type']
+              enum: TParameter['enum']
+            }>
+          : unknown
+    }
   : {
-    [TName in TParameter['name']]?: TParameter extends Checks['Schemas'] ? FromSchema<TParameter['schema']>
-      : TParameter extends Checks['Enum'] ? FromSchema<{
-          type: TParameter['type']
-          enum: TParameter['enum']
-        }>
-      : unknown
-  }
+      [TName in TParameter['name']]?: TParameter extends Checks['Schemas']
+        ? FromSchema<TParameter['schema']>
+        : TParameter extends Checks['Enum']
+          ? FromSchema<{
+              type: TParameter['type']
+              enum: TParameter['enum']
+            }>
+          : unknown
+    }
 
 interface ParamToRequestParam<TParameters extends Checks['Parameters']> extends Fn {
   return: this['arg0'] extends { name: string; in: infer TParamType }
-    // If there is any required parameter for this parameter type, make that parameter type required
-    ? TParameters extends Checks<TParamType>['SingleParameter'] ? {
-        [
-          TKey in TParamType extends keyof ParamPropMap ? ParamPropMap[TParamType]
-            : never
-        ]: ParamObj<this['arg0']>
-      }
-    : {
-      [
-        TKey in TParamType extends keyof ParamPropMap ? ParamPropMap[TParamType]
-          : never
-      ]?: ParamObj<this['arg0']>
-    }
+    ? // If there is any required parameter for this parameter type, make that parameter type required
+      TParameters extends Checks<TParamType>['SingleParameter']
+      ? {
+          [TKey in TParamType extends keyof ParamPropMap ? ParamPropMap[TParamType] : never]: ParamObj<this['arg0']>
+        }
+      : {
+          [TKey in TParamType extends keyof ParamPropMap ? ParamPropMap[TParamType] : never]?: ParamObj<this['arg0']>
+        }
     : {}
 }
 
-export type ParamMap<TParameters extends Checks['Parameters']> = Pipe<
-  TParameters,
-  [Tuples.Map<ParamToRequestParam<TParameters>>, Tuples.ToIntersection]
->
+export type ParamMap<TParameters extends Checks['Parameters']> = Pipe<TParameters, [Tuples.Map<ParamToRequestParam<TParameters>>, Tuples.ToIntersection]>
 
-export type MethodMap<
-  TOAS extends OasTypes.OASDocument,
-  TPath extends keyof PathMap<TOAS>,
-> = PathMap<TOAS>[TPath]
+export type MethodMap<TOAS extends OasTypes.OASDocument, TPath extends keyof PathMap<TOAS>> = PathMap<TOAS>[TPath]
 
-export type StatusMap<
-  TOAS extends OasTypes.OASDocument,
-  TPath extends keyof PathMap<TOAS>,
-  TMethod extends keyof MethodMap<TOAS, TPath>,
-> = MethodMap<TOAS, TPath>[TMethod] extends Checks['Responses'] ? MethodMap<TOAS, TPath>[TMethod]['responses']
+export type StatusMap<TOAS extends OasTypes.OASDocument, TPath extends keyof PathMap<TOAS>, TMethod extends keyof MethodMap<TOAS, TPath>> = MethodMap<
+  TOAS,
+  TPath
+>[TMethod] extends Checks['Responses']
+  ? MethodMap<TOAS, TPath>[TMethod]['responses']
   : never

package/src/oas/model.ts

@@ -1,8 +1,5 @@
 import type { OasTypes } from '@kubb/swagger/oas'
-import type {
-  FromSchema,
-  JSONSchema,
-} from 'json-schema-to-ts'
+import type { FromSchema, JSONSchema } from 'json-schema-to-ts'
 
 type Checks<TName extends string | number | symbol = never> = {
   ModelWithSchemas: {
@@ -29,9 +26,13 @@ type Checks<TName extends string | number | symbol = never> = {
 
 export type Model<
   TOAS extends OasTypes.OASDocument,
-  TName extends TOAS extends Checks['ModelWithSchemas'] ? keyof TOAS['components']['schemas']
-    : TOAS extends Checks['ModelWithDefinitions'] ? keyof TOAS['definitions']
-    : never,
-> = TOAS extends Checks<TName>['ModelWithSchemasNamed'] ? FromSchema<TOAS['components']['schemas'][TName]>
-  : TOAS extends Checks<TName>['ModelWithDefinitionsNamed'] ? FromSchema<TOAS['definitions'][TName]>
-  : never
+  TName extends TOAS extends Checks['ModelWithSchemas']
+    ? keyof TOAS['components']['schemas']
+    : TOAS extends Checks['ModelWithDefinitions']
+      ? keyof TOAS['definitions']
+      : never,
+> = TOAS extends Checks<TName>['ModelWithSchemasNamed']
+  ? FromSchema<TOAS['components']['schemas'][TName]>
+  : TOAS extends Checks<TName>['ModelWithDefinitionsNamed']
+    ? FromSchema<TOAS['definitions'][TName]>
+    : never