ts-procedures 7.2.0 → 8.0.0

package/src/codegen/targets/_shared/route-slots.test.ts

@@ -2,54 +2,137 @@ import { describe, expect, it } from 'vitest'
 import { extractRouteSlots } from './route-slots.js'
 import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
 
-const r = (schema: Record<string, unknown> | undefined): AnyHttpRouteDoc =>
-  ({ name: 'X', kind: 'api', method: 'GET', fullPath: '/x', schema } as unknown as AnyHttpRouteDoc)
+// Helpers for constructing minimal route docs per kind
+function apiRoute(jsonSchema: Record<string, unknown>): AnyHttpRouteDoc {
+  return { name: 'X', kind: 'api', method: 'get', path: '/x', fullPath: '/x', jsonSchema } as unknown as AnyHttpRouteDoc
+}
 
-describe('extractRouteSlots', () => {
-  it('returns no slots when schema is undefined', () => {
-    expect(extractRouteSlots(r(undefined))).toEqual([])
-  })
+function httpStreamRoute(jsonSchema: Record<string, unknown>): AnyHttpRouteDoc {
+  return { name: 'X', kind: 'http-stream', method: 'get', path: '/x', fullPath: '/x', streamMode: 'sse', jsonSchema } as unknown as AnyHttpRouteDoc
+}
+
+function rpcRoute(jsonSchema: Record<string, unknown>): AnyHttpRouteDoc {
+  return { name: 'X', kind: 'rpc', method: 'post', path: '/x', scope: 'x', version: 1, jsonSchema } as unknown as AnyHttpRouteDoc
+}
 
-  it('returns no slots when schema is empty', () => {
-    expect(extractRouteSlots(r({}))).toEqual([])
+function streamRoute(jsonSchema: Record<string, unknown>): AnyHttpRouteDoc {
+  return { name: 'X', kind: 'stream', path: '/x', scope: 'x', version: 1, methods: ['get'], streamMode: 'sse', jsonSchema } as unknown as AnyHttpRouteDoc
+}
+
+describe('extractRouteSlots — api kind', () => {
+  it('returns no slots when jsonSchema is empty', () => {
+    expect(extractRouteSlots(apiRoute({}))).toEqual([])
   })
 
-  it('returns the deterministic slot order: PathParams, Query, Body, Response', () => {
+  it('returns the deterministic slot order: PathParams, Query, Body, Headers, Response, ResponseHeaders', () => {
     const slots = extractRouteSlots(
-      r({
-        input: {
-          body: { type: 'object', x: 'body' },
-          query: { type: 'object', x: 'query' },
-          pathParams: { type: 'object', x: 'path' },
+      apiRoute({
+        req: {
+          body: { type: 'object', tag: 'body' },
+          query: { type: 'object', tag: 'query' },
+          pathParams: { type: 'object', tag: 'path' },
+          headers: { type: 'object', tag: 'headers' },
+        },
+        res: {
+          body: { type: 'object', tag: 'response' },
+          headers: { type: 'object', tag: 'resHeaders' },
         },
-        returnType: { type: 'object', x: 'response' },
       }),
     )
-    expect(slots.map((s) => s.rootName)).toEqual(['PathParams', 'Query', 'Body', 'Response'])
+    expect(slots.map((s) => s.rootName)).toEqual(['PathParams', 'Query', 'Body', 'Headers', 'Response', 'ResponseHeaders'])
   })
 
   it('omits slots whose source is null or undefined', () => {
     const slots = extractRouteSlots(
-      r({
-        input: { pathParams: { type: 'object' }, query: null, body: undefined },
-        // returnType missing
+      apiRoute({
+        req: { pathParams: { type: 'object' }, query: null, body: undefined },
       }),
     )
     expect(slots.map((s) => s.rootName)).toEqual(['PathParams'])
   })
 
-  it('attaches the source schema verbatim to each slot', () => {
+  it('attaches source schemas verbatim', () => {
     const path = { type: 'object', tag: 'p' }
-    const ret = { type: 'object', tag: 'r' }
-    const slots = extractRouteSlots(r({ input: { pathParams: path }, returnType: ret }))
+    const body = { type: 'object', tag: 'b' }
+    const slots = extractRouteSlots(apiRoute({ req: { pathParams: path, body }, res: {} }))
     expect(slots).toEqual([
       { rootName: 'PathParams', source: path },
-      { rootName: 'Response', source: ret },
+      { rootName: 'Body', source: body },
+    ])
+  })
+
+  it('reads responseHeaders from res.headers', () => {
+    const resHeaders = { type: 'object', tag: 'rh' }
+    const slots = extractRouteSlots(apiRoute({ res: { headers: resHeaders } }))
+    expect(slots).toEqual([{ rootName: 'ResponseHeaders', source: resHeaders }])
+  })
+})
+
+describe('extractRouteSlots — http-stream kind', () => {
+  it('returns no slots when jsonSchema is empty', () => {
+    expect(extractRouteSlots(httpStreamRoute({}))).toEqual([])
+  })
+
+  it('returns the deterministic slot order: PathParams, Query, Body, Headers, ResponseHeaders, Yield, ReturnType', () => {
+    const slots = extractRouteSlots(
+      httpStreamRoute({
+        req: {
+          pathParams: { type: 'object', tag: 'path' },
+          query: { type: 'object', tag: 'query' },
+          body: { type: 'object', tag: 'body' },
+          headers: { type: 'object', tag: 'headers' },
+        },
+        res: { headers: { type: 'object', tag: 'resHeaders' } },
+        yield: { type: 'object', tag: 'yield' },
+        returnType: { type: 'object', tag: 'return' },
+      }),
+    )
+    expect(slots.map((s) => s.rootName)).toEqual([
+      'PathParams', 'Query', 'Body', 'Headers', 'ResponseHeaders', 'Yield', 'ReturnType',
     ])
   })
 
-  it('returns no slots for stream/no-schema routes', () => {
-    const stream = { name: 'S', kind: 'stream', method: 'GET', path: '/s' } as unknown as AnyHttpRouteDoc
-    expect(extractRouteSlots(stream)).toEqual([])
+  it('attaches yield and returnType sources correctly', () => {
+    const yieldSchema = { type: 'object', tag: 'y' }
+    const returnSchema = { type: 'object', tag: 'r' }
+    const slots = extractRouteSlots(httpStreamRoute({ yield: yieldSchema, returnType: returnSchema }))
+    expect(slots).toEqual([
+      { rootName: 'Yield', source: yieldSchema },
+      { rootName: 'ReturnType', source: returnSchema },
+    ])
+  })
+})
+
+describe('extractRouteSlots — rpc kind', () => {
+  it('returns no slots when jsonSchema is empty', () => {
+    expect(extractRouteSlots(rpcRoute({}))).toEqual([])
+  })
+
+  it('maps body and response slots', () => {
+    const body = { type: 'object', tag: 'b' }
+    const response = { type: 'object', tag: 'r' }
+    const slots = extractRouteSlots(rpcRoute({ body, response }))
+    expect(slots).toEqual([
+      { rootName: 'Body', source: body },
+      { rootName: 'Response', source: response },
+    ])
+  })
+})
+
+describe('extractRouteSlots — stream kind', () => {
+  it('returns no slots when jsonSchema is empty', () => {
+    expect(extractRouteSlots(streamRoute({}))).toEqual([])
+  })
+
+  it('maps params→Body, yieldType→Yield, returnType→ReturnType', () => {
+    const params = { type: 'object', tag: 'p' }
+    const yieldType = { type: 'object', tag: 'y' }
+    const returnType = { type: 'object', tag: 'r' }
+    const slots = extractRouteSlots(streamRoute({ params, yieldType, returnType }))
+    expect(slots).toEqual([
+      { rootName: 'Body', source: params },
+      { rootName: 'Yield', source: yieldType },
+      { rootName: 'ReturnType', source: returnType },
+    ])
   })
 })

package/src/codegen/targets/_shared/route-slots.ts

@@ -1,9 +1,8 @@
 import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
 
 /**
- * A "slot" is one of the deterministic schema sources a route exposes:
- * `pathParams`, `query`, `body` (under `schema.input`) and the response
- * (`schema.returnType`). Targets emit one type per non-null slot.
+ * A "slot" is one of the deterministic schema sources a route exposes.
+ * Targets emit one type per non-null slot.
  */
 export interface RouteSlot {
   /** Stable identifier used as the emitted type's `rootTypeName`. */
@@ -15,18 +14,56 @@ export interface RouteSlot {
 /**
  * Returns the deterministic ordered slot list for a route, filtered to slots
  * with non-null sources. Order is fixed at the module level for stable output.
+ *
+ * Kind dispatch:
+ * - `'api'`         — reads from `jsonSchema.req` / `jsonSchema.res` (new envelope shape)
+ * - `'http-stream'` — reads from `jsonSchema.req` / `jsonSchema.res` / `jsonSchema.yield` / `jsonSchema.returnType`
+ * - `'rpc'`         — reads from `jsonSchema.body` / `jsonSchema.response`
+ * - `'stream'`      — reads from `jsonSchema.params` / `jsonSchema.yieldType` / `jsonSchema.returnType`
  */
 export function extractRouteSlots(route: AnyHttpRouteDoc): RouteSlot[] {
-  const schema = (route as { schema?: Record<string, unknown> }).schema ?? {}
-  const input = (schema.input ?? {}) as Record<string, unknown>
+  const kind = route.kind
 
   // Order is load-bearing: targets emit slots in this sequence.
-  const slots: RouteSlot[] = [
-    { rootName: 'PathParams', source: input.pathParams },
-    { rootName: 'Query', source: input.query },
-    { rootName: 'Body', source: input.body },
-    { rootName: 'Response', source: schema.returnType },
-  ]
+  let slots: RouteSlot[]
+
+  if (kind === 'api') {
+    const req = route.jsonSchema.req ?? {}
+    const res = route.jsonSchema.res ?? {}
+    slots = [
+      { rootName: 'PathParams', source: req.pathParams },
+      { rootName: 'Query', source: req.query },
+      { rootName: 'Body', source: req.body },
+      { rootName: 'Headers', source: req.headers },
+      { rootName: 'Response', source: res.body },
+      { rootName: 'ResponseHeaders', source: res.headers },
+    ]
+  } else if (kind === 'http-stream') {
+    const req = route.jsonSchema.req ?? {}
+    const res = route.jsonSchema.res ?? {}
+    slots = [
+      { rootName: 'PathParams', source: req.pathParams },
+      { rootName: 'Query', source: req.query },
+      { rootName: 'Body', source: req.body },
+      { rootName: 'Headers', source: req.headers },
+      { rootName: 'ResponseHeaders', source: res.headers },
+      { rootName: 'Yield', source: route.jsonSchema.yield },
+      { rootName: 'ReturnType', source: route.jsonSchema.returnType },
+    ]
+  } else if (kind === 'rpc') {
+    slots = [
+      { rootName: 'Body', source: route.jsonSchema.body },
+      { rootName: 'Response', source: route.jsonSchema.response },
+    ]
+  } else if (kind === 'stream') {
+    slots = [
+      { rootName: 'Body', source: route.jsonSchema.params },
+      { rootName: 'Yield', source: route.jsonSchema.yieldType },
+      { rootName: 'ReturnType', source: route.jsonSchema.returnType },
+    ]
+  } else {
+    slots = []
+  }
 
   return slots.filter((s) => s.source != null)
 }

package/src/codegen/targets/kotlin/__fixtures__/users-golden.kt

@@ -118,4 +118,77 @@ object Users {
             )
         }
     }
+
+    object DownloadUser {
+        const val method = "GET"
+        const val pathTemplate = "/users/{id}/download"
+        fun path(p: PathParams): String = "/users/${p.id}/download"
+
+        @Serializable
+        data class PathParams(
+            val id: String,
+        )
+
+        @Serializable
+        data class Response(
+            val id: String,
+            val name: String,
+            @SerialName("created-at") @Contextual val createdAt: java.time.Instant,
+            val address: Address,
+        ) {
+            @Serializable
+            data class Address(
+                val street: String,
+                val city: String,
+            )
+        }
+
+        @Serializable
+        data class ResponseHeaders(
+            @SerialName("x-download-token") val xDownloadToken: String,
+            @SerialName("content-disposition") val contentDisposition: String? = null,
+        )
+    }
+
+    object WatchUsers {
+        const val method = "GET"
+        const val pathTemplate = "/users/watch"
+        const val path = "/users/watch"
+
+        @Serializable
+        data class Query(
+            val status: Status? = null,
+            val limit: Long? = null,
+        ) {
+            @Serializable
+            enum class Status {
+                @SerialName("active") ACTIVE,
+                @SerialName("inactive") INACTIVE,
+            }
+        }
+
+        @Serializable
+        data class ResponseHeaders(
+            @SerialName("x-download-token") val xDownloadToken: String,
+            @SerialName("content-disposition") val contentDisposition: String? = null,
+        )
+
+        @Serializable
+        data class Yield(
+            val id: String,
+            val event: Event,
+        ) {
+            @Serializable
+            enum class Event {
+                @SerialName("created") CREATED,
+                @SerialName("updated") UPDATED,
+                @SerialName("deleted") DELETED,
+            }
+        }
+
+        @Serializable
+        data class ReturnType(
+            val count: Long,
+        )
+    }
 }

package/src/codegen/targets/kotlin/emit-route-kotlin.test.ts

@@ -34,11 +34,9 @@ describe('emitKotlinRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: {
-        input: {
-          pathParams: { type: 'object' },
-        },
-        returnType: { type: 'object' },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
       },
       errors: [],
     } as unknown as AnyHttpRouteDoc
@@ -64,7 +62,10 @@ describe('emitKotlinRoute', () => {
       name: 'CreateUser',
       method: 'POST',
       fullPath: '/users',
-      schema: { input: { body: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { body: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -84,7 +85,10 @@ describe('emitKotlinRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
 
@@ -103,14 +107,14 @@ describe('emitKotlinRoute', () => {
   it('silently skips error keys with no schema in the envelope map', () => {
     const route = {
       kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users',
-      schema: {}, errors: ['UnknownTaxonomyKey'],
+      jsonSchema: {}, errors: ['UnknownTaxonomyKey'],
     } as unknown as AnyHttpRouteDoc
     const result = emitKotlinRoute(route, createStubKotlinEmitter({}), new Map())
     expect(result.code).not.toContain('object Errors {')
   })
 
   it('returns skipped:true for stream routes', () => {
-    const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const result = emitKotlinRoute(route, createStubKotlinEmitter({}), noErrors)
     expect(result.code).toBe('')
     expect(result.skipped).toBe(true)
@@ -122,9 +126,9 @@ describe('emitKotlinRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: {
-        input: { pathParams: { type: 'object' } },
-        returnType: { type: 'object' },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
       },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
@@ -155,13 +159,13 @@ describe('emitKotlinRoute', () => {
       name: 'X',
       method: 'POST',
       fullPath: '/x/:id',
-      schema: {
-        input: {
+      jsonSchema: {
+        req: {
           pathParams: { type: 'object' },
           query: { type: 'object' },
           body: { type: 'object' },
         },
-        returnType: { type: 'object' },
+        res: { body: { type: 'object' } },
       },
       errors: ['Z'],
     } as unknown as AnyHttpRouteDoc
@@ -187,7 +191,7 @@ describe('emitKotlinRoute', () => {
       name: 'X',
       method: 'GET',
       fullPath: '/x',
-      schema: { returnType: { type: 'object' } },
+      jsonSchema: { res: { body: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -207,13 +211,92 @@ describe('emitKotlinRoute', () => {
     expect(calls[0]!.opts.uncountableWords).toEqual(['data', 'metadata'])
   })
 
+  it('emits ResponseHeaders slot when res.headers is declared on an api route', () => {
+    const route = {
+      kind: 'api',
+      name: 'DownloadUser',
+      method: 'GET',
+      fullPath: '/users/:id/download',
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: {
+          body: { type: 'object' },
+          headers: { type: 'object' },
+        },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('@Serializable data class PathParams(val id: String)', 'PathParams'),
+      Response: ok('@Serializable data class Response(val url: String)', 'Response'),
+      ResponseHeaders: ok(
+        '@Serializable\ndata class ResponseHeaders(\n    @SerialName("x-download-token") val xDownloadToken: String,\n)',
+        'ResponseHeaders',
+      ),
+    })
+
+    const result = emitKotlinRoute(route, emitter, noErrors)
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual(['PathParams', 'Response', 'ResponseHeaders'])
+    expect(result.code).toContain('@SerialName("x-download-token") val xDownloadToken: String')
+  })
+
+  it('does not emit ResponseHeaders when res.headers is absent', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('@Serializable data class PathParams(val id: String)', 'PathParams'),
+      Response: ok('@Serializable data class Response(val id: String)', 'Response'),
+    })
+
+    emitKotlinRoute(route, emitter, noErrors)
+    expect(calls.map((c) => c.opts.rootTypeName)).not.toContain('ResponseHeaders')
+  })
+
+  it('processes http-stream routes (not skipped) and emits Yield/ReturnType slots', () => {
+    const route = {
+      kind: 'http-stream',
+      name: 'TailLogs',
+      method: 'GET',
+      fullPath: '/logs/tail',
+      jsonSchema: {
+        req: { query: { type: 'object' } },
+        yield: { type: 'object' },
+        returnType: { type: 'object' },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      Query: ok('@Serializable data class Query(val filter: String? = null)', 'Query'),
+      Yield: ok('@Serializable data class Yield(val line: String)', 'Yield'),
+      ReturnType: ok('@Serializable data class ReturnType(val count: Long)', 'ReturnType'),
+    })
+
+    const result = emitKotlinRoute(route, emitter, noErrors)
+    expect(result.skipped).toBeFalsy()
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual(['Query', 'Yield', 'ReturnType'])
+    expect(result.code).toContain('const val method = "GET"')
+    expect(result.code).toContain('const val path = "/logs/tail"')
+  })
+
   it('does not include passthrough keys when caller omits them', () => {
     const route = {
       kind: 'api',
       name: 'X',
       method: 'GET',
       fullPath: '/x',
-      schema: { returnType: { type: 'object' } },
+      jsonSchema: { res: { body: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 

package/src/codegen/targets/kotlin/emit-scope-kotlin.test.ts

@@ -18,7 +18,10 @@ describe('emitKotlinScope', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -40,8 +43,8 @@ describe('emitKotlinScope', () => {
   })
 
   it('joins multiple routes inside one scope object', () => {
-    const route1 = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users/:id', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
-    const route2 = { kind: 'api', name: 'CreateUser', method: 'POST', fullPath: '/users', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route1 = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users/:id', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route2 = { kind: 'api', name: 'CreateUser', method: 'POST', fullPath: '/users', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route1, route2] }
     const emitter = createStubKotlinEmitter({})
 
@@ -60,7 +63,7 @@ describe('emitKotlinScope', () => {
   })
 
   it('threads all 5 passthrough opts to every emitter call', () => {
-    const route = { kind: 'api', name: 'X', method: 'GET', fullPath: '/x', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'api', name: 'X', method: 'GET', fullPath: '/x', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'x', camelCase: 'x', routes: [route] }
 
     const calls: KotlinEmitOptions[] = []
@@ -96,8 +99,8 @@ describe('emitKotlinScope', () => {
   })
 
   it('collects skipped stream-route names', () => {
-    const stream = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/u/stream', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
-    const api = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/u', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const stream = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/u/stream', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const api = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/u', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'u', camelCase: 'u', routes: [stream, api] }
 
     const emitter = createStubKotlinEmitter({

package/src/codegen/targets/kotlin/integration.test.ts

@@ -61,6 +61,25 @@ describe('kotlin codegen — integration', () => {
         'Query',
         ['kotlinx.serialization.Serializable', 'kotlinx.serialization.SerialName'],
       ),
+
+      // DownloadUser
+      ResponseHeaders: ok(
+        '@Serializable\ndata class ResponseHeaders(\n    @SerialName("x-download-token") val xDownloadToken: String,\n    @SerialName("content-disposition") val contentDisposition: String? = null,\n)',
+        'ResponseHeaders',
+        ['kotlinx.serialization.Serializable', 'kotlinx.serialization.SerialName'],
+      ),
+
+      // WatchUsers (http-stream) — reuses Query and ResponseHeaders stubs from above;
+      // adds Yield and ReturnType which are unique to the stream route.
+      Yield: ok(
+        '@Serializable\ndata class Yield(\n    val id: String,\n    val event: Event,\n) {\n    @Serializable\n    enum class Event {\n        @SerialName("created") CREATED,\n        @SerialName("updated") UPDATED,\n        @SerialName("deleted") DELETED,\n    }\n}',
+        'Yield',
+        ['kotlinx.serialization.Serializable', 'kotlinx.serialization.SerialName'],
+      ),
+      ReturnType: ok(
+        '@Serializable\ndata class ReturnType(\n    val count: Long,\n)',
+        'ReturnType',
+      ),
     })
 
     const files = await runPipeline({

package/src/codegen/targets/swift/__fixtures__/users-golden.swift

@@ -120,4 +120,83 @@ public enum Users {
             }
         }
     }
+
+    public enum DownloadUser {
+        public static let method = "GET"
+        public static let pathTemplate = "/users/{id}/download"
+        public static func path(_ p: PathParams) -> String { return "/users/\(p.id)/download" }
+
+        public struct PathParams: Codable {
+            public let id: String
+        }
+
+        public struct Response: Codable {
+            public let id: String
+            public let name: String
+            public let createdAt: Date
+            public let address: Address
+
+            enum CodingKeys: String, CodingKey {
+                case id, name
+                case createdAt = "created-at"
+                case address
+            }
+
+            public struct Address: Codable {
+                public let street: String
+                public let city: String
+            }
+        }
+
+        public struct ResponseHeaders: Codable {
+            public let xDownloadToken: String
+            public let contentDisposition: String?
+
+            enum CodingKeys: String, CodingKey {
+                case xDownloadToken = "x-download-token"
+                case contentDisposition = "content-disposition"
+            }
+        }
+    }
+
+    public enum WatchUsers {
+        public static let method = "GET"
+        public static let pathTemplate = "/users/watch"
+        public static let path = "/users/watch"
+
+        public struct Query: Codable {
+            public let status: Status?
+            public let limit: Int64?
+
+            public enum Status: String, Codable {
+                case active
+                case inactive
+            }
+        }
+
+        public struct ResponseHeaders: Codable {
+            public let xDownloadToken: String
+            public let contentDisposition: String?
+
+            enum CodingKeys: String, CodingKey {
+                case xDownloadToken = "x-download-token"
+                case contentDisposition = "content-disposition"
+            }
+        }
+
+        public struct Yield: Codable {
+            public let id: String
+            public let event: Event
+
+            public enum Event: String, Codable {
+                case created
+                case updated
+                case deleted
+            }
+        }
+
+        public struct ReturnType: Codable {
+            public let count: Int64
+        }
+    }
 }