@kubb/plugin-ts 5.0.0-alpha.22 → 5.0.0-alpha.23

package/src/resolvers/resolverTs.ts

@@ -19,8 +19,7 @@ function resolveName(name: string, type?: 'file' | 'function' | 'type' | 'const'
  * import { resolver } from '@kubb/plugin-ts'
  *
  * resolver.default('list pets', 'type')              // → 'ListPets'
- * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
- * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
+ * resolver.resolveName('list pets status 200')        // → 'ListPetsStatus200'
  * resolver.resolvePathName('list pets', 'file')       // → 'listPets'
  * ```
  */
@@ -34,74 +33,38 @@ export const resolverTs = defineResolver<PluginTs>(() => {
     resolveName(name) {
       return this.default(name, 'function')
     },
-    resolveTypedName(name) {
-      return this.default(name, 'type')
-    },
     resolvePathName(name, type) {
       return this.default(name, type)
     },
     resolveParamName(node, param) {
-      return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`)
-    },
-    resolveParamTypedName(node, param) {
-      return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`)
+      return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
     },
     resolveResponseStatusName(node, statusCode) {
       return this.resolveName(`${node.operationId} Status ${statusCode}`)
     },
-    resolveResponseStatusTypedName(node, statusCode) {
-      return this.resolveTypedName(`${node.operationId} Status ${statusCode}`)
-    },
     resolveDataName(node) {
       return this.resolveName(`${node.operationId} Data`)
     },
-    resolveDataTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Data`)
-    },
     resolveRequestConfigName(node) {
       return this.resolveName(`${node.operationId} RequestConfig`)
     },
-    resolveRequestConfigTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} RequestConfig`)
-    },
     resolveResponsesName(node) {
       return this.resolveName(`${node.operationId} Responses`)
     },
-    resolveResponsesTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Responses`)
-    },
     resolveResponseName(node) {
       return this.resolveName(`${node.operationId} Response`)
     },
-    resolveResponseTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Response`)
-    },
-    resolveEnumKeyTypedName(node, enumTypeSuffix = 'key') {
-      return `${this.resolveTypedName(node.name ?? '')}${enumTypeSuffix}`
-    },
-    resolvePathParamsName(_node) {
-      throw new Error("resolvePathParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.")
-    },
-    resolvePathParamsTypedName(_node) {
-      throw new Error(
-        "resolvePathParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.",
-      )
-    },
-    resolveQueryParamsName(_node) {
-      throw new Error("resolveQueryParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.")
+    resolveEnumKeyName(node, enumTypeSuffix = 'key') {
+      return `${this.resolveName(node.name ?? '')}${enumTypeSuffix}`
     },
-    resolveQueryParamsTypedName(_node) {
-      throw new Error(
-        "resolveQueryParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.",
-      )
+    resolvePathParamsName(node, param) {
+      return this.resolveParamName(node, param)
     },
-    resolveHeaderParamsName(_node) {
-      throw new Error("resolveHeaderParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.")
+    resolveQueryParamsName(node, param) {
+      return this.resolveParamName(node, param)
     },
-    resolveHeaderParamsTypedName(_node) {
-      throw new Error(
-        "resolveHeaderParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.",
-      )
+    resolveHeaderParamsName(node, param) {
+      return this.resolveParamName(node, param)
     },
   }
 })

package/src/resolvers/resolverTsLegacy.ts

@@ -35,53 +35,26 @@ export const resolverTsLegacy = defineResolver<PluginTs>(() => {
       }
       return this.resolveName(`${node.operationId} ${statusCode}`)
     },
-    resolveResponseStatusTypedName(node, statusCode) {
-      if (statusCode === 'default') {
-        return this.resolveTypedName(`${node.operationId} Error`)
-      }
-      return this.resolveTypedName(`${node.operationId} ${statusCode}`)
-    },
     resolveDataName(node) {
       const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
       return this.resolveName(`${node.operationId} ${suffix}`)
     },
-    resolveDataTypedName(node) {
-      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
-      return this.resolveTypedName(`${node.operationId} ${suffix}`)
-    },
     resolveResponsesName(node) {
       const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
-      return `${this.default(node.operationId, 'function')}${suffix}`
-    },
-    resolveResponsesTypedName(node) {
-      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
-      return `${this.default(node.operationId, 'type')}${suffix}`
+      return this.resolveName(`${node.operationId} ${suffix}`)
     },
     resolveResponseName(node) {
       const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
       return this.resolveName(`${node.operationId} ${suffix}`)
     },
-    resolveResponseTypedName(node) {
-      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
-      return this.resolveTypedName(`${node.operationId} ${suffix}`)
-    },
-    resolvePathParamsName(node) {
+    resolvePathParamsName(node, _param) {
       return this.resolveName(`${node.operationId} PathParams`)
     },
-    resolvePathParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} PathParams`)
-    },
-    resolveQueryParamsName(node) {
+    resolveQueryParamsName(node, _param) {
       return this.resolveName(`${node.operationId} QueryParams`)
     },
-    resolveQueryParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} QueryParams`)
-    },
-    resolveHeaderParamsName(node) {
+    resolveHeaderParamsName(node, _param) {
       return this.resolveName(`${node.operationId} HeaderParams`)
     },
-    resolveHeaderParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} HeaderParams`)
-    },
   }
 })

package/src/types.ts

@@ -1,6 +1,6 @@
+import type { OperationParamsResolver } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from '@kubb/ast/types'
 import type {
-  Builder,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -11,233 +11,94 @@ import type {
   PluginFactoryOptions,
   ResolvePathOptions,
   Resolver,
+  UserGroup,
 } from '@kubb/core'
 /**
  * The concrete resolver type for `@kubb/plugin-ts`.
  * Extends the base `Resolver` (which provides `default` and `resolveOptions`) with
  * plugin-specific naming helpers for operations, parameters, responses, and schemas.
  */
-export type ResolverTs = Resolver & {
-  /**
-   * Resolves the variable/function name for a given raw name (equivalent to `default(name, 'function')`).
-   * Use this shorthand when matching the `name` field produced by the v2 TypeGenerator,
-   * so call-sites don't need to repeat the `'function'` type literal.
-   *
-   * @example
-   * resolver.resolveName('list pets status 200') // → 'listPetsStatus200'
-   */
-  resolveName(name: string): string
-  /**
-   * Resolves the TypeScript type name for a given raw name (equivalent to `default(name, 'type')`).
-   * Use this shorthand when matching the `typedName` field produced by the v2 TypeGenerator,
-   * so call-sites don't need to repeat the `'type'` type literal.
-   *
-   * @example
-   * resolver.resolveTypedName('list pets status 200') // → 'ListPetsStatus200'
-   */
-  resolveTypedName(name: string): string
-  /**
-   * Resolves the file/path name for a given identifier using PascalCase.
-   *
-   * @example
-   * resolver.resolvePathName('list pets', 'file') // → 'ListPets'
-   */
-  resolvePathName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-  /**
-   * Resolves the variable/function name for an operation parameter.
-   * Encapsulates the `<operationId> <PascalCase(paramIn)> <paramName>` naming convention.
-   *
-   * @example
-   * resolver.resolveParamName(node, param) // → 'ListPetsQueryLimit'
-   */
-  resolveParamName(node: OperationNode, param: ParameterNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation parameter
-   * (equivalent to `resolveParamName` with `type: 'type'`).
-   * In the default implementation both return the same PascalCase string;
-   * the distinction is preserved so overrides can diverge the two forms.
-   *
-   * @example
-   * resolver.resolveParamTypedName(node, param) // → 'ListPetsQueryLimit'
-   */
-  resolveParamTypedName(node: OperationNode, param: ParameterNode): string
-  /**
-   * Resolves the variable/function name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example
-   * resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'
-   */
-  resolveResponseStatusName(node: OperationNode, statusCode: StatusCode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example
-   * resolver.resolveResponseStatusTypedName(node, 200) // → 'ListPetsStatus200'
-   */
-  resolveResponseStatusTypedName(node: OperationNode, statusCode: StatusCode): string
-  /**
-   * Resolves the variable/function name for an operation's request body (`Data`).
-   *
-   * @example
-   * resolver.resolveDataName(node) // → 'ListPetsData'
-   */
-  resolveDataName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's request body (`Data`).
-   *
-   * @example
-   * resolver.resolveDataTypedName(node) // → 'ListPetsData'
-   */
-  resolveDataTypedName(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for an operation's request config (`RequestConfig`).
-   *
-   * @example
-   * resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'
-   */
-  resolveRequestConfigName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's request config (`RequestConfig`).
-   *
-   * @example
-   * resolver.resolveRequestConfigTypedName(node) // → 'ListPetsRequestConfig'
-   */
-  resolveRequestConfigTypedName(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for the collection of all operation responses (`Responses`).
-   *
-   * @example
-   * resolver.resolveResponsesName(node) // → 'ListPetsResponses'
-   */
-  resolveResponsesName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for the collection of all operation responses.
-   *
-   * @example
-   * resolver.resolveResponsesTypedName(node) // → 'ListPetsResponses'
-   */
-  resolveResponsesTypedName(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for the union of all operation responses (`Response`).
-   *
-   * @example
-   * resolver.resolveResponseName(node) // → 'ListPetsResponse'
-   */
-  resolveResponseName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for the union of all operation responses.
-   *
-   * @example
-   * resolver.resolveResponseTypedName(node) // → 'ListPetsResponse'
-   */
-  resolveResponseTypedName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an enum schema's key variant.
-   * Appends `enumTypeSuffix` (default `'Key'`) after applying the default naming convention.
-   *
-   * @example
-   * resolver.resolveEnumKeyTypedName(node, 'Key')   // → 'PetStatusKey'
-   * resolver.resolveEnumKeyTypedName(node, 'Value') // → 'PetStatusValue'
-   * resolver.resolveEnumKeyTypedName(node, '')      // → 'PetStatus'
-   */
-  resolveEnumKeyTypedName(node: SchemaNode, enumTypeSuffix: string): string
-  /**
-   * Resolves the variable/function name for an operation's grouped path parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamName` per individual parameter instead.
-   * @example
-   * resolver.resolvePathParamsName(node) // → 'GetPetByIdPathParams'
-   */
-  resolvePathParamsName?(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's grouped path parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolvePathParamsTypedName(node) // → 'GetPetByIdPathParams'
-   */
-  resolvePathParamsTypedName?(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for an operation's grouped query parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamName` per individual parameter instead.
-   * @example
-   * resolver.resolveQueryParamsName(node) // → 'FindPetsByStatusQueryParams'
-   */
-  resolveQueryParamsName?(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's grouped query parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolveQueryParamsTypedName(node) // → 'FindPetsByStatusQueryParams'
-   */
-  resolveQueryParamsTypedName?(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for an operation's grouped header parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamName` per individual parameter instead.
-   * @example
-   * resolver.resolveHeaderParamsName(node) // → 'DeletePetHeaderParams'
-   */
-  resolveHeaderParamsName?(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's grouped header parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolveHeaderParamsTypedName(node) // → 'DeletePetHeaderParams'
-   */
-  resolveHeaderParamsTypedName?(node: OperationNode): string
-}
-
-/**
- * Options for building a grouped parameter schema (`pathParams`, `queryParams`, `headerParams`).
- */
-type BuildParamsSchemaOptions = {
-  params: Array<ParameterNode>
-  node: OperationNode
-  resolver: ResolverTs
-}
+export type ResolverTs = Resolver &
+  OperationParamsResolver & {
+    /**
+     * Resolves the name for a given raw name (equivalent to `default(name, 'function')`).
+     * Since TypeScript only emits types, this is the canonical naming method.
+     *
+     * @example
+     * resolver.resolveName('list pets status 200') // → 'ListPetsStatus200'
+     */
+    resolveName(name: string): string
+    /**
+     * Resolves the file/path name for a given identifier using PascalCase.
+     *
+     * @example
+     * resolver.resolvePathName('list pets', 'file') // → 'ListPets'
+     */
+    resolvePathName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+    /** Resolves the request body type name (required on ResolverTs). */
+    resolveDataName(node: OperationNode): string
 
-/**
- * Options for building an operation-level schema (`data`, `responses`, `responseUnion`).
- */
-type BuildOperationSchemaOptions = {
-  node: OperationNode
-  resolver: ResolverTs
-}
-
-/**
- * The concrete builder type for `@kubb/plugin-ts`.
- * Extends the base `Builder` with schema-building helpers used by the v5 type generator.
- */
-export type BuilderTs = Builder & {
-  /**
-   * Builds an object schema that groups the given parameters by name.
-   */
-  buildParams(options: BuildParamsSchemaOptions): SchemaNode
-  /**
-   * Builds the combined data schema containing `pathParams`, `queryParams`, `headerParams`, `data`, and `url`.
-   */
-  buildData(options: BuildOperationSchemaOptions): SchemaNode
-  /**
-   * Builds an object schema that maps each response status code to its type reference, or `null` when there are no responses.
-   */
-  buildResponses(options: BuildOperationSchemaOptions): SchemaNode | null
-  /**
-   * Builds a union schema of all response status types, or `null` when no responses have a schema.
-   */
-  buildResponseUnion(options: BuildOperationSchemaOptions): SchemaNode | null
-}
+    /**
+     * Resolves the name for an operation response by status code.
+     * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
+     *
+     * @example
+     * resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'
+     */
+    resolveResponseStatusName(node: OperationNode, statusCode: StatusCode): string
+    /**
+     * Resolves the name for an operation's request config (`RequestConfig`).
+     *
+     * @example
+     * resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'
+     */
+    resolveRequestConfigName(node: OperationNode): string
+    /**
+     * Resolves the name for the collection of all operation responses (`Responses`).
+     *
+     * @example
+     * resolver.resolveResponsesName(node) // → 'ListPetsResponses'
+     */
+    resolveResponsesName(node: OperationNode): string
+    /**
+     * Resolves the name for the union of all operation responses (`Response`).
+     *
+     * @example
+     * resolver.resolveResponseName(node) // → 'ListPetsResponse'
+     */
+    resolveResponseName(node: OperationNode): string
+    /**
+     * Resolves the TypeScript type alias name for an enum schema's key variant.
+     * Appends `enumTypeSuffix` (default `'Key'`) after applying the default naming convention.
+     *
+     * @example
+     * resolver.resolveEnumKeyName(node, 'Key')   // → 'PetStatusKey'
+     * resolver.resolveEnumKeyName(node, 'Value') // → 'PetStatusValue'
+     * resolver.resolveEnumKeyName(node, '')      // → 'PetStatus'
+     */
+    resolveEnumKeyName(node: SchemaNode, enumTypeSuffix: string): string
+    /**
+     * Resolves the name for an operation's grouped path parameters type.
+     *
+     * @example
+     * resolver.resolvePathParamsName(node, param) // → 'GetPetByIdPathParams'
+     */
+    resolvePathParamsName(node: OperationNode, param: ParameterNode): string
+    /**
+     * Resolves the name for an operation's grouped query parameters type.
+     *
+     * @example
+     * resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'
+     */
+    resolveQueryParamsName(node: OperationNode, param: ParameterNode): string
+    /**
+     * Resolves the name for an operation's grouped header parameters type.
+     *
+     * @example
+     * resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'
+     */
+    resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string
+  }
 
 export type Options = {
   /**
@@ -253,7 +114,7 @@ export type Options = {
   /**
    * Group the clients based on the provided name.
    */
-  group?: Group
+  group?: UserGroup
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
    */
@@ -371,7 +232,7 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
-  group: Options['group']
+  group: Group | undefined
   enumType: NonNullable<Options['enumType']>
   enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>
   enumKeyCasing: NonNullable<Options['enumKeyCasing']>
@@ -379,8 +240,7 @@ type ResolvedOptions = {
   arrayType: NonNullable<Options['arrayType']>
   syntaxType: NonNullable<Options['syntaxType']>
   paramsCasing: Options['paramsCasing']
-  resolver: ResolverTs
   transformers: Array<Visitor>
 }
 
-export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs, BuilderTs>
+export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>

package/src/utils.ts

@@ -0,0 +1,103 @@
+import { createProperty, createSchema } from '@kubb/ast'
+import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import type { ResolverTs } from './types.ts'
+
+type BuildParamsSchemaOptions = {
+  params: Array<ParameterNode>
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+type BuildOperationSchemaOptions = {
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+export function buildParams({ params, node, resolver }: BuildParamsSchemaOptions): SchemaNode {
+  return createSchema({
+    type: 'object',
+    properties: params.map((param) =>
+      createProperty({
+        name: param.name,
+        required: param.required,
+        schema: createSchema({
+          type: 'ref',
+          name: resolver.resolveParamName(node, param),
+        }),
+      }),
+    ),
+  })
+}
+
+export function buildData({ node, resolver }: BuildOperationSchemaOptions): SchemaNode {
+  const pathParams = node.parameters.filter((p) => p.in === 'path')
+  const queryParams = node.parameters.filter((p) => p.in === 'query')
+  const headerParams = node.parameters.filter((p) => p.in === 'header')
+
+  return createSchema({
+    type: 'object',
+    deprecated: node.deprecated,
+    properties: [
+      createProperty({
+        name: 'data',
+        schema: node.requestBody?.schema
+          ? createSchema({ type: 'ref', name: resolver.resolveDataName(node), optional: true })
+          : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'pathParams',
+        required: pathParams.length > 0,
+        schema: pathParams.length > 0 ? buildParams({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
+      }),
+      createProperty({
+        name: 'queryParams',
+        schema:
+          queryParams.length > 0
+            ? createSchema({ ...buildParams({ params: queryParams, node, resolver }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'headerParams',
+        schema:
+          headerParams.length > 0
+            ? createSchema({ ...buildParams({ params: headerParams, node, resolver }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'url',
+        required: true,
+        schema: createSchema({ type: 'url', path: node.path }),
+      }),
+    ],
+  })
+}
+
+export function buildResponses({ node, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  if (node.responses.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'object',
+    properties: node.responses.map((res) =>
+      createProperty({
+        name: String(res.statusCode),
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) }),
+      }),
+    ),
+  })
+}
+
+export function buildResponseUnion({ node, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  const responsesWithSchema = node.responses.filter((res) => res.schema)
+
+  if (responsesWithSchema.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'union',
+    members: responsesWithSchema.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+  })
+}