@@ -31,7 +31,9 @@ export class RestParameter {
 
     const lines: string[] = []
     const required = param.required ? ' (required)' : ''
-    const type = param.schema?.type || 'string'
+    const type = Array.isArray(param.schema?.type)
+      ? param.schema.type.join(' or ')
+      : param.schema?.type || 'string'
 
     lines.push(`- **\`${param.name}\`** (${type})${required}`)
 
 
@@ -9,6 +9,7 @@ import getCodeSamples from './create-rest-examples'
 import operationSchema from './operation-schema'
 import { validateJson } from '@/tests/lib/validate-json-schema'
 import { getBodyParams, type TransformedParam } from './get-body-params'
+import { simplifyParameterSchema } from './parameter-schema'
 import type { OpenApiOperation, OpenApiParameter, OpenApiServer } from './openapi-types'
 import type { MergedExample } from './create-rest-examples'
 
@@ -155,12 +156,8 @@ export default class Operation {
           delete param.example
           delete param.examples
           delete param['x-multi-segment']
-          // Keep only parameter schema subfields that renderers consume: type, default, and enum.
           if (param.schema && typeof param.schema === 'object') {
-            const { type, default: defaultVal, enum: enumVal } = param.schema
-            param.schema = { type }
-            if (defaultVal !== undefined) param.schema.default = defaultVal
-            if (enumVal !== undefined) param.schema.enum = enumVal
+            param.schema = simplifyParameterSchema(param.schema)
           }
           return param
         }),
 
@@ -0,0 +1,45 @@
+import type { OpenApiParameterSchema } from './openapi-types'
+
+interface SchemaVariant {
+  type?: string | string[]
+  enum?: unknown[]
+  items?: { type?: unknown; enum?: unknown[] }
+}
+
+// Keep only the schema fields that parameter renderers read: type, default, and enum.
+// Multi-type parameters use oneOf or anyOf with no top-level type, so their type
+// and allowed values come from the variants instead.
+export function simplifyParameterSchema(schema: OpenApiParameterSchema): OpenApiParameterSchema {
+  const { type, default: defaultVal } = schema
+  let enumVal = schema.enum
+  const simplified: OpenApiParameterSchema = { type }
+
+  const variants = (schema.oneOf ?? schema.anyOf) as SchemaVariant[] | undefined
+  if (type === undefined && Array.isArray(variants)) {
+    const types = new Set<string>()
+    const enums = new Set<unknown>()
+    let everyVariantRestricted = variants.length > 0
+    for (const variant of variants) {
+      const variantTypes = Array.isArray(variant.type) ? variant.type : [variant.type]
+      for (const variantType of variantTypes) {
+        if (variantType === undefined) continue
+        // Match the "array of <type>s" wording that body parameters use.
+        types.add(
+          variantType === 'array' && typeof variant.items?.type === 'string'
+            ? `array of ${variant.items.type}s`
+            : variantType,
+        )
+      }
+      const variantEnum = variant.enum ?? variant.items?.enum
+      if (!variantEnum?.length) everyVariantRestricted = false
+      for (const value of variantEnum ?? []) enums.add(value)
+    }
+    if (types.size > 0) simplified.type = types.size === 1 ? [...types][0] : [...types]
+    // A variant without an enum accepts any value, so a combined list would wrongly narrow the parameter.
+    if (enumVal === undefined && everyVariantRestricted) enumVal = [...enums]
+  }
+
+  if (defaultVal !== undefined) simplified.default = defaultVal
+  if (enumVal !== undefined) simplified.enum = enumVal
+  return simplified
+}
@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest'
+
+import { simplifyParameterSchema } from '@/rest/scripts/utils/parameter-schema'
+
+describe('simplifyParameterSchema', () => {
+  test('keeps only type, default, and enum for a typed schema', () => {
+    expect(
+      simplifyParameterSchema({
+        type: 'string',
+        default: 'open',
+        enum: ['open', 'closed'],
+        example: 'open',
+      }),
+    ).toEqual({ type: 'string', default: 'open', enum: ['open', 'closed'] })
+  })
+
+  test('derives the type from oneOf variants', () => {
+    expect(
+      simplifyParameterSchema({
+        oneOf: [{ type: 'integer' }, { type: 'string' }],
+      }),
+    ).toEqual({ type: ['integer', 'string'] })
+  })
+
+  test('describes array variants by item type and omits enum when a variant is unrestricted', () => {
+    expect(
+      simplifyParameterSchema({
+        oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string', enum: ['patch'] } }],
+      }),
+    ).toEqual({ type: ['string', 'array of strings'] })
+  })
+
+  test('combines enum values when every variant is restricted', () => {
+    expect(
+      simplifyParameterSchema({
+        oneOf: [
+          { type: 'string', enum: ['patch'] },
+          { type: 'array', items: { type: 'string', enum: ['patch', 'deployment'] } },
+        ],
+      }),
+    ).toEqual({ type: ['string', 'array of strings'], enum: ['patch', 'deployment'] })
+  })
+
+  test('derives the type from anyOf variants and drops duplicate types', () => {
+    expect(
+      simplifyParameterSchema({
+        anyOf: [{ type: 'string' }, { type: 'string', enum: ['all'] }],
+        default: 'all',
+      }),
+    ).toEqual({ type: 'string', default: 'all' })
+  })
+
+  test('leaves the type undefined for an empty schema', () => {
+    expect(simplifyParameterSchema({})).toEqual({ type: undefined })
+  })
+})