@kubb/plugin-oas 3.0.0-alpha.3 → 3.0.0-alpha.31

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

@@ -1,11 +1,13 @@
 import type { PluginFactoryOptions } from '@kubb/core'
-import type { Operation, SchemaObject } from '@kubb/oas'
-import { App, createRoot, type KubbNode } from '@kubb/react'
 import type * as KubbFile from '@kubb/fs/types'
-import type { OperationsByMethod } from './types.ts'
+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 { 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'>
@@ -22,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 }) {
@@ -60,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>,
       )
@@ -80,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>,
@@ -92,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 []
       }
@@ -102,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'

package/src/hooks/useOperationManager.ts

@@ -13,7 +13,7 @@ type FileMeta = FileMetaBase & {
   tag?: string
 }
 
-type SchemaNames = {
+export type SchemaNames = {
   request: string | undefined
   parameters: {
     path: string | undefined
@@ -25,14 +25,41 @@ type SchemaNames = {
 }
 
 type UseOperationManagerResult = {
-  getName: (operation: OperationType, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => string
-  getFile: (operation: OperationType, params?: { pluginKey?: Plugin['key']; extName?: KubbFile.Extname }) => KubbFile.File<FileMeta>
-  groupSchemasByName: (operation: OperationType, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => SchemaNames
-  getSchemas: (
+  getName: (
+    operation: OperationType,
+    params: {
+      prefix?: string
+      suffix?: string
+      pluginKey?: Plugin['key']
+      type: ResolveNameParams['type']
+    },
+  ) => string
+  getSchemaName: (
     operation: Operation,
-    params?: { pluginKey?: Plugin['key']; type?: ResolveNameParams['type'] },
-    forStatusCode?: string | number,
-  ) => OperationSchemas
+    key: keyof Omit<OperationSchemas, 'errors' | 'statusCodes'>,
+    params?: {
+      pluginKey?: Plugin['key']
+      type?: ResolveNameParams['type']
+    },
+  ) => string
+  getFile: (
+    operation: OperationType,
+    params?: {
+      prefix?: string
+      suffix?: string
+      pluginKey?: Plugin['key']
+      extname?: KubbFile.Extname
+      tag?: string
+    },
+  ) => KubbFile.File<FileMeta>
+  groupSchemasByName: (
+    operation: OperationType,
+    params: {
+      pluginKey?: Plugin['key']
+      type: ResolveNameParams['type']
+    },
+  ) => SchemaNames
+  getSchemas: (operation: Operation, params?: { pluginKey?: Plugin['key']; type?: ResolveNameParams['type'] }) => OperationSchemas
 }
 
 /**
@@ -42,26 +69,51 @@ export function useOperationManager(): UseOperationManagerResult {
   const { plugin, pluginManager } = useApp()
   const { generator } = useContext(Oas.Context)
 
-  if (!generator) {
-    throw new Error(`'generator' is not defined`)
-  }
-
-  const getName: UseOperationManagerResult['getName'] = (operation, { pluginKey = plugin.key, type }) => {
+  const getName: UseOperationManagerResult['getName'] = (operation, { prefix = '', suffix = '', pluginKey = plugin.key, type }) => {
     return pluginManager.resolveName({
-      name: operation.getOperationId(),
+      name: `${prefix} ${operation.getOperationId()} ${suffix}`,
       pluginKey,
       type,
     })
   }
 
-  const getFile: UseOperationManagerResult['getFile'] = (operation, { pluginKey = plugin.key, extName = '.ts' } = {}) => {
-    // needed for the `output.group`
-    const tag = operation.getTags().at(0)?.name
-    const name = getName(operation, { type: 'file', pluginKey })
+  const getSchemas: UseOperationManagerResult['getSchemas'] = (operation, params) => {
+    if (!generator) {
+      throw new Error(`'generator' is not defined`)
+    }
 
+    return generator.getSchemas(operation, {
+      resolveName: (name) =>
+        pluginManager.resolveName({
+          name,
+          pluginKey: params?.pluginKey,
+          type: params?.type,
+        }),
+    })
+  }
+
+  const getSchemaName: UseOperationManagerResult['getSchemaName'] = (operation, key, { pluginKey = plugin.key, type } = {}) => {
+    const schemas = getSchemas(operation)
+
+    if (!schemas[key]?.name) {
+      throw new Error(`SchemaName not found for ${operation.getOperationId()}`)
+    }
+
+    return pluginManager.resolveName({
+      name: schemas[key]?.name,
+      pluginKey,
+      type,
+    })
+  }
+  //TODO replace tag with group
+  const getFile: UseOperationManagerResult['getFile'] = (
+    operation,
+    { prefix, suffix, pluginKey = plugin.key, tag = operation.getTags().at(0)?.name, extname = '.ts' } = {},
+  ) => {
+    const name = getName(operation, { type: 'file', pluginKey, prefix, suffix })
     const file = pluginManager.getFile({
       name,
-      extName,
+      extname,
       pluginKey,
       options: { type: 'file', pluginKey, tag },
     })
@@ -78,6 +130,10 @@ export function useOperationManager(): UseOperationManagerResult {
   }
 
   const groupSchemasByName: UseOperationManagerResult['groupSchemasByName'] = (operation, { pluginKey = plugin.key, type }) => {
+    if (!generator) {
+      throw new Error(`'generator' is not defined`)
+    }
+
     const schemas = generator.getSchemas(operation)
 
     const errors = (schemas.errors || []).reduce(
@@ -148,16 +204,8 @@ export function useOperationManager(): UseOperationManagerResult {
   return {
     getName,
     getFile,
-    getSchemas: (operation, params, forStatusCode) =>
-      generator.getSchemas(operation, {
-        forStatusCode,
-        resolveName: (name) =>
-          pluginManager.resolveName({
-            name,
-            pluginKey: params?.pluginKey,
-            type: params?.type,
-          }),
-      }),
+    getSchemas,
+    getSchemaName,
     groupSchemasByName,
   }
 }

package/src/hooks/useSchemaManager.ts

@@ -0,0 +1,77 @@
+import { useApp } from '@kubb/react'
+
+import type { FileMetaBase, Plugin, ResolveNameParams } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
+import type { Mode } from '@kubb/fs/types'
+import { SchemaGenerator } from '../SchemaGenerator.ts'
+import { type Schema, schemaKeywords } from '../SchemaMapper'
+
+type FileMeta = FileMetaBase & {
+  pluginKey: Plugin['key']
+  name: string
+  tag?: string
+}
+
+type UseSchemaManagerResult = {
+  getName: (name: string, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => string
+  getFile: (name: string, params?: { pluginKey?: Plugin['key']; mode?: Mode; extname?: KubbFile.Extname; tag?: string }) => KubbFile.File<FileMeta>
+  getImports: (tree: Array<Schema>) => Array<KubbFile.Import>
+}
+
+/**
+ * `useSchemaManager` will return some helper functions that can be used to get the schema file, get the schema name.
+ */
+export function useSchemaManager(): UseSchemaManagerResult {
+  const { mode, plugin, pluginManager, fileManager } = useApp()
+
+  const getName: UseSchemaManagerResult['getName'] = (name, { pluginKey = plugin.key, type }) => {
+    return pluginManager.resolveName({
+      name,
+      pluginKey,
+      type,
+    })
+  }
+  //TODO replace tag with group
+  const getFile: UseSchemaManagerResult['getFile'] = (name, { mode = 'split', pluginKey = plugin.key, extname = '.ts', tag } = {}) => {
+    const resolvedName = mode === 'single' ? '' : getName(name, { type: 'file', pluginKey })
+
+    const file = pluginManager.getFile({
+      name: resolvedName,
+      extname,
+      pluginKey,
+      options: { type: 'file', pluginKey, tag },
+    })
+
+    return {
+      ...file,
+      meta: {
+        ...file.meta,
+        name: resolvedName,
+        pluginKey,
+      },
+    }
+  }
+
+  const getImports: UseSchemaManagerResult['getImports'] = (tree) => {
+    const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref)
+
+    return refs
+      ?.map((item, i) => {
+        if (!item.args.path) {
+          return undefined
+        }
+
+        return {
+          name: [item.args.name],
+          path: item.args.path,
+        }
+      })
+      .filter(Boolean)
+  }
+
+  return {
+    getName,
+    getFile,
+    getImports,
+  }
+}

package/src/index.ts

@@ -20,6 +20,6 @@ export type {
 } from './SchemaMapper.ts'
 export { isKeyword, schemaKeywords } from './SchemaMapper.ts'
 export type * from './types.ts'
-export { createParser, createReactParser } from './parser.tsx'
-export type { ParserReactOptions } from './parser.tsx'
-export type { Parser, ParserOptions } from './parser.tsx'
+export { createGenerator, createReactGenerator } from './generator.tsx'
+export type { ReactGeneratorOptions } from './generator.tsx'
+export type { Generator, GeneratorOptions } from './generator.tsx'

package/src/plugin.ts

@@ -1,34 +1,35 @@
-import path from 'node:path'
-
-import { createPlugin } from '@kubb/core'
-import { camelCase } from '@kubb/core/transformers'
+import { FileManager, createPlugin } from '@kubb/core'
 
 import { getSchemas } from './utils/getSchemas.ts'
+import { parseFromConfig } from './utils/parseFromConfig.ts'
 
+import path from 'node:path'
 import type { Config } from '@kubb/core'
 import type { Logger } from '@kubb/core/logger'
-import type { Oas, OasTypes } from '@kubb/oas'
-import type { FormatOptions } from '@kubb/oas/parser'
+import type { Oas } from '@kubb/oas'
+import { OperationGenerator } from './OperationGenerator.ts'
+import { SchemaGenerator } from './SchemaGenerator.ts'
+import { jsonGenerator } from './generators'
 import type { PluginOas } from './types.ts'
-import { parseFromConfig } from './utils/parseFromConfig.ts'
 
 export const pluginOasName = 'plugin-oas' satisfies PluginOas['name']
 
 export const pluginOas = createPlugin<PluginOas>((options) => {
   const {
-    output = { path: 'schemas', export: false },
-    experimentalFilter: filter,
-    experimentalSort: sort,
+    output = {
+      path: 'schemas',
+    },
     validate = true,
+    generators = [jsonGenerator],
     serverIndex = 0,
     contentType,
     oasClass,
   } = options
 
-  const getOas = async ({ config, logger, formatOptions }: { config: Config; logger: Logger; formatOptions?: FormatOptions }): Promise<Oas> => {
+  const getOas = async ({ config, logger }: { config: Config; logger: Logger }): Promise<Oas> => {
     try {
       // needs to be in a different variable or the catch here will not work(return of a promise instead)
-      const oas = await parseFromConfig(config, formatOptions, oasClass)
+      const oas = await parseFromConfig(config, oasClass)
 
       if (validate) {
         await oas.valdiate()
@@ -39,19 +40,22 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
       const error = e as Error
 
       logger.emit('warning', error?.message)
-      return parseFromConfig(config, {}, oasClass)
+      return parseFromConfig(config, oasClass)
     }
   }
 
   return {
     name: pluginOasName,
-    options,
+    options: {
+      output,
+      ...options,
+    },
     context() {
       const { config, logger } = this
 
       return {
-        getOas(formatOptions) {
-          return getOas({ config, logger, formatOptions })
+        getOas() {
+          return getOas({ config, logger })
         },
         async getSchemas({ includes } = {}) {
           const oas = await this.getOas()
@@ -59,24 +63,25 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
         },
         async getBaseURL() {
           const oasInstance = await this.getOas()
-          const baseURL = oasInstance.api.servers?.at(serverIndex)?.url
-          return baseURL
+          return oasInstance.api.servers?.at(serverIndex)?.url
         },
         contentType,
       }
     },
-    resolvePath(baseName) {
-      if (output === false) {
-        return undefined
-      }
-
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
+
+      if (mode === 'single') {
+        /**
+         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
+         */
+        return path.resolve(root, output.path)
+      }
 
       return path.resolve(root, output.path, baseName)
     },
-    resolveName(name, type) {
-      return camelCase(name, { isFile: type === 'file' })
-    },
     async buildStart() {
       if (!output) {
         return
@@ -85,42 +90,45 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
       const oas = await getOas({
         config: this.config,
         logger: this.logger,
-        formatOptions: {
-          filterSet: filter,
-          sortSet: sort,
-        },
       })
       await oas.dereference()
-      const schemas = getSchemas({ oas, contentType })
-
-      const mapSchema = async ([name, schema]: [string, OasTypes.SchemaObject]) => {
-        const resolvedPath = this.resolvePath({
-          baseName: `${name}.json`,
-          pluginKey: this.plugin.key,
-        })
-
-        const resvoledFileName = this.resolveName({
-          name: `${name}.json`,
-          pluginKey: [pluginOasName],
-          type: 'file',
-        }) as `${string}.json`
-
-        if (!resolvedPath) {
-          return
-        }
-
-        await this.addFile({
-          path: resolvedPath,
-          baseName: resvoledFileName,
-          source: JSON.stringify(schema),
-          meta: {
-            pluginKey: this.plugin.key,
-          },
-        })
-      }
 
-      const promises = Object.entries(schemas).map(mapSchema)
-      await Promise.all(promises)
+      const schemaGenerator = new SchemaGenerator(
+        {
+          unknownType: 'unknown',
+          dateType: 'date',
+          transformers: {},
+          ...this.plugin.options,
+        },
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType,
+          include: undefined,
+          override: undefined,
+          mode: 'split',
+          output: output.path,
+        },
+      )
+
+      const schemaFiles = await schemaGenerator.build(...generators)
+      await this.addFile(...schemaFiles)
+
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType,
+        exclude: undefined,
+        include: undefined,
+        override: undefined,
+        mode: 'split',
+      })
+
+      const operationFiles = await operationGenerator.build(...generators)
+
+      await this.addFile(...operationFiles)
     },
   }
 })

package/src/types.ts

@@ -1,9 +1,9 @@
-import type { Plugin } from '@kubb/core'
+import type { Output, Plugin } from '@kubb/core'
 import type { PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 import type * as KubbFile from '@kubb/fs/types'
 
 import type { HttpMethod, Oas, Operation, SchemaObject, contentType } from '@kubb/oas'
-import type { FormatOptions } from '@kubb/oas/parser'
+import type { Generator } from './generator.tsx'
 import type { GetSchemasProps } from './utils/getSchemas.ts'
 
 export type ResolvePathOptions = {
@@ -13,7 +13,7 @@ export type ResolvePathOptions = {
 }
 
 export type API = {
-  getOas: (formatOptions?: FormatOptions) => Promise<Oas>
+  getOas: () => Promise<Oas>
   getSchemas: (options?: Pick<GetSchemasProps, 'includes'>) => Promise<Record<string, SchemaObject>>
   getBaseURL: () => Promise<string | undefined>
   contentType?: contentType
@@ -25,16 +25,10 @@ export type Options = {
    * @default true
    */
   validate?: boolean
-  output?:
-    | {
-        /**
-         * Relative path to save the JSON models.
-         * False will not generate the schema JSON's.
-         * @default 'schemas'
-         */
-        path: string
-      }
-    | false
+  /**
+   * @default 'schemas'
+   */
+  output?: Output
   /**
    * Which server to use from the array of `servers.url[serverIndex]`
    * @example
@@ -48,9 +42,14 @@ export type Options = {
    * By default, this is set based on the first used contentType..
    */
   contentType?: contentType
-  experimentalFilter?: FormatOptions['filterSet']
-  experimentalSort?: FormatOptions['sortSet']
+  /**
+   * Override some behaviour of the Oas class instance, see '@kubb/oas'
+   */
   oasClass?: typeof Oas
+  /**
+   * Define some generators next to the JSON generation
+   */
+  generators?: Array<Generator<PluginOas>>
 }
 
 /**
@@ -128,6 +127,11 @@ type ByMethod = {
   type: 'method'
   pattern: HttpMethod | RegExp
 }
+// TODO implement as alternative for ByMethod
+type ByMethods = {
+  type: 'methods'
+  pattern: Array<HttpMethod>
+}
 
 type BySchemaName = {
   type: 'schemaName'
@@ -141,4 +145,8 @@ export type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | By
   options: Partial<TOptions>
 }
 
-export type PluginOas = PluginFactoryOptions<'plugin-oas', Options, Options, API, never>
+type ResolvedOptions = Options & {
+  output: Output
+}
+
+export type PluginOas = PluginFactoryOptions<'plugin-oas', Options, ResolvedOptions, API, never>