@sdk-it/typescript 0.39.0 → 0.41.0

package/dist/index.js

@@ -172,8 +172,10 @@ var ZodEmitter = class {
    */
   normal(type, schema, required = false, nullable = false) {
     switch (type) {
-      case "string":
-        return `${this.string(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
+      case "string": {
+        const defaultVal = (schema["x-zod-type"] === "date" || schema["x-zod-type"] === "coerce-date") && schema.default ? `new Date(${JSON.stringify(schema.default)})` : JSON.stringify(schema.default);
+        return `${this.string(schema)}${this.#suffixes(defaultVal, required, nullable)}`;
+      }
       case "number":
       case "integer": {
         const { base, defaultValue } = this.#number(schema);
@@ -259,10 +261,16 @@ var ZodEmitter = class {
     switch (schema.format) {
       case "date-time":
       case "datetime":
-        base = "z.string().datetime()";
+        if (schema["x-zod-type"] === "coerce-date") {
+          base = "z.coerce.date()";
+        } else if (schema["x-zod-type"] === "date") {
+          base = "z.date()";
+        } else {
+          base = "z.string().datetime()";
+        }
         break;
       case "date":
-        base = "z.coerce.date()";
+        base = "z.string().date()";
         break;
       case "time":
         base = "z.string() /* optionally add .regex(...) for HH:MM:SS format */";
@@ -305,14 +313,16 @@ var ZodEmitter = class {
    */
   #number(schema) {
     let defaultValue = schema.default;
-    let base = "z.number()";
+    let base;
     if (schema.format === "int64") {
-      base = "z.bigint()";
+      base = schema["x-zod-type"] === "coerce-bigint" ? "z.coerce.bigint()" : "z.bigint()";
       if (schema.default !== void 0) {
         defaultValue = `BigInt(${schema.default})`;
       }
+    } else {
+      base = schema["x-zod-type"] === "coerce-number" ? "z.coerce.number()" : "z.number()";
     }
-    if (schema.format === "int32") {
+    if (schema.type === "integer" && schema.format !== "int64") {
       base += ".int()";
     }
     if (typeof schema.exclusiveMinimum === "number") {
@@ -415,17 +425,20 @@ var client_default = (spec) => {
         token = await Promise.resolve(token());
       }
       return \`Bearer \${token}\`;
-    })`
+    }).describe('Bearer token for authentication. Can be a string or a function that returns a string.')`
       }
     } : {},
     fetch: {
-      schema: "fetchType"
+      schema: `fetchType.describe('Custom fetch implementation. Defaults to globalThis.fetch.')`
     },
     baseUrl: {
-      schema: spec.servers.length ? `z.enum(servers).default(servers[0])` : "z.string()"
+      schema: spec.servers.length ? `z.enum(servers).default(servers[0]).describe('Base URL of the API server.')` : `z.string().describe('Base URL of the API server.')`
     },
     headers: {
-      schema: "z.record(z.string()).optional()"
+      schema: `z.record(z.string()).optional().describe('Default headers to include in all requests.')`
+    },
+    skipValidation: {
+      schema: `z.boolean().optional().describe('Skip request input validation. Client options and TypeScript types still enforce correct usage.')`
     }
   };
   return `import z from 'zod';
@@ -453,6 +466,7 @@ export class ${spec.name} {
     this.options = options;
   }
 
+  /** Sends a request and returns the unwrapped response data. Delegates to the standalone {@link request} function. */
   async request<const E extends keyof typeof schemas>(
     endpoint: E,
     input: z.input<(typeof schemas)[E]['schema']>,
@@ -466,32 +480,13 @@ export class ${spec.name} {
     });
   }
 
+  /** Builds a ready-to-send request without sending it. Delegates to the standalone {@link prepare} function. */
   async prepare<const E extends keyof typeof schemas>(
     endpoint: E,
     input: z.input<(typeof schemas)[E]['schema']>,
     options?: { headers?: HeadersInit },
-  ): Promise<RequestConfig & {
-    parse: (response: Response) => ReturnType<typeof parse>;
-  }> {
-    const clientOptions = await optionsSchema.parseAsync(this.options);
-    const route = schemas[endpoint];
-    const interceptors = [
-      createHeadersInterceptor(
-        await this.defaultHeaders(),
-        options?.headers ?? {},
-      ),
-      createBaseUrlInterceptor(clientOptions.baseUrl),
-    ];
-    const parsedInput = parseInput(route.schema, input);
-
-    let config = route.toRequest(parsedInput as never);
-    for (const interceptor of interceptors) {
-      if (interceptor.before) {
-        config = await interceptor.before(config);
-      }
-    }
-    const prepared = { ...config, parse: (response: Response) => parse(route.output, response, (d) => d) as never };
-    return prepared as any;
+  ) {
+    return prepare(this, endpoint, input, options);
   }
 
   async defaultHeaders() {
@@ -516,34 +511,89 @@ export class ${spec.name} {
 
 }
 
+/**
+ * Sends a validated request using the client's configuration and returns the parsed response.
+ * Merges the client's default inputs and headers before sending.
+ * Throws \`APIError\` on non-ok responses.
+ *
+ * @example
+ * \`\`\`ts
+ * const result = await request(client, 'GET /users', { limit: 10 });
+ * \`\`\`
+ */
 export async function request<const E extends keyof typeof schemas>(
   client: ${spec.name},
   endpoint: E,
   input: z.input<(typeof schemas)[E]['schema']>,
-  options?: { signal?: AbortSignal; headers?: HeadersInit },
+  requestOptions?: { signal?: AbortSignal; headers?: HeadersInit },
 ): Promise<Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>> {
   const route = schemas[endpoint];
+  const options = await optionsSchema.parseAsync(client.options);
   const withDefaultInputs = Object.assign(
     {},
-    await client.defaultInputs(),
+    ${defaultInputs},
     input,
   );
-  const parsedInput = parseInput(route.schema, withDefaultInputs);
-  const clientOptions = await optionsSchema.parseAsync(client.options);
+  const parsedInput = options.skipValidation ? withDefaultInputs : parseInput(route.schema, withDefaultInputs);
   const result = await route.dispatch(parsedInput as never, {
-    fetch: clientOptions.fetch,
+    fetch: options.fetch,
     interceptors: [
       createHeadersInterceptor(
-        await client.defaultHeaders(),
-        options?.headers ?? {},
+        { ...${defaultHeaders}, ...options.headers },
+        requestOptions?.headers ?? {},
       ),
-      createBaseUrlInterceptor(clientOptions.baseUrl),
+      createBaseUrlInterceptor(options.baseUrl),
     ],
-    signal: options?.signal,
+    signal: requestOptions?.signal,
   });
   return result as Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>;
 }
 
+/**
+ * Builds a validated \`RequestConfig\` (url + init) with a \`parse\` function attached, without sending.
+ * Use when you need control over the fetch call \u2014 framework integration (Next.js, SvelteKit),
+ * custom retry/logging, request batching, or testing.
+ *
+ * @example
+ * \`\`\`ts
+ * const { url, init, parse } = await prepare(client, 'GET /users', { limit: 10 });
+ * const response = await fetch(new Request(url, init));
+ * const result = await parse(response);
+ * \`\`\`
+ */
+export async function prepare<const E extends keyof typeof schemas>(
+  client: ${spec.name},
+  endpoint: E,
+  input: z.input<(typeof schemas)[E]['schema']>,
+  requestOptions?: { headers?: HeadersInit },
+): Promise<RequestConfig & {
+  parse: (response: Response) => ReturnType<typeof parse>;
+}> {
+  const route = schemas[endpoint];
+  const options = await optionsSchema.parseAsync(client.options);
+  const withDefaultInputs = Object.assign(
+    {},
+    ${defaultInputs},
+    input,
+  );
+  const parsedInput = options.skipValidation ? withDefaultInputs : parseInput(route.schema, withDefaultInputs);
+  const interceptors = [
+    createHeadersInterceptor(
+      { ...${defaultHeaders}, ...options.headers },
+      requestOptions?.headers ?? {},
+    ),
+    createBaseUrlInterceptor(options.baseUrl),
+  ];
+
+  let config = route.toRequest(parsedInput as never);
+  for (const interceptor of interceptors) {
+    if (interceptor.before) {
+      config = await interceptor.before(config);
+    }
+  }
+  return { ...config, parse: (response: Response) => parse(route.output as never, response, (d) => d) as never } as any;
+}
+
 
 `;
 };
@@ -652,7 +702,7 @@ var TypeScriptEmitter = class {
       case "date-time":
       case "datetime":
       case "date":
-        type = "Date";
+        type = "string";
         break;
       case "binary":
       case "byte":
@@ -728,6 +778,8 @@ import {
 import { camelcase as camelcase3 } from "stringcase";
 import { isEmpty, pascalcase as pascalcase3 } from "@sdk-it/core";
 import {
+  isBinaryContentType,
+  isSseContentType,
   isStreamingContentType,
   isTextContentType,
   parseJsonContentType,
@@ -754,6 +806,7 @@ var status_map_default = {
   "412": "PreconditionFailed",
   "413": "PayloadTooLarge",
   "410": "Gone",
+  "415": "UnsupportedMediaType",
   "422": "UnprocessableEntity",
   "429": "TooManyRequests",
   "500": "InternalServerError",
@@ -928,16 +981,31 @@ function fromContentType(spec, typeScriptDeserialzer, response) {
   if ((response.headers ?? {})["Transfer-Encoding"]) {
     return streamedOutput();
   }
+  const hasContentDisposition = hasHeader(response, "Content-Disposition");
   for (const type in response.content) {
-    if (isStreamingContentType(type)) {
+    const isStreaming = isStreamingContentType(type);
+    const isBinary = isBinaryContentType(type) || isStreaming && hasContentDisposition;
+    if (isStreaming && !hasContentDisposition) {
       return streamedOutput();
     }
+    if (isBinary) {
+      return {
+        parser: "buffered",
+        responseSchema: response.content[type].schema ? typeScriptDeserialzer.handle(response.content[type].schema, true) : "Blob"
+      };
+    }
     if (parseJsonContentType(type)) {
       return {
         parser: "buffered",
         responseSchema: response.content[type].schema ? typeScriptDeserialzer.handle(response.content[type].schema, true) : "void"
       };
     }
+    if (isSseContentType(type)) {
+      return {
+        parser: "sse",
+        responseSchema: "SSEListener"
+      };
+    }
     if (isTextContentType(type)) {
       return {
         parser: "buffered",
@@ -947,6 +1015,11 @@ function fromContentType(spec, typeScriptDeserialzer, response) {
   }
   return streamedOutput();
 }
+function hasHeader(response, name) {
+  const headers = response.headers ?? {};
+  const target = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === target);
+}
 function streamedOutput() {
   return {
     parser: "chunked",
@@ -1108,6 +1181,7 @@ ${allSchemas.map((it) => it.use).join(",\n")}
                 `import * as outputs from '${config.makeImport("../outputs/index")}';`,
                 `import { toRequest, json, urlencoded, empty, formdata, type HeadersInit } from '${config.makeImport("../http/request")}';`,
                 `import { chunked, buffered } from "${config.makeImport("../http/parse-response")}";`,
+                `import { sse } from "${config.makeImport("../http/sse")}";`,
                 `import * as ${camelcase4(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`,
                 `import { createBaseUrlInterceptor, createHeadersInterceptor, type Interceptor } from '${config.makeImport("../http/interceptors")}';`,
                 `import { Dispatcher, fetchType, type InstanceType } from '${config.makeImport("../http/dispatcher")}';`,
@@ -1236,13 +1310,13 @@ function operationSchema(ir, operation, type) {
 }
 
 // packages/typescript/src/lib/http/dispatcher.txt
-var dispatcher_default = "export type Unionize<T> = T extends [infer Single extends OutputType]\n  ? InstanceType<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: InstanceType<Tuple[I]> }[number]\n    : never;\n\nexport type InstanceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends { type: Type<infer U> }\n      ? U\n      : T extends Array<unknown>\n        ? Unionize<T>\n        : never;\n\ntype ResponseData<T extends OutputType[]> =\n  Extract<InstanceType<T>, SuccessfulResponse> extends SuccessfulResponse<\n    infer P\n  >\n    ? P\n    : unknown;\n\ntype ResponseMapper<T extends OutputType[], R> = (data: ResponseData<T>) => R;\n\nexport interface Type<T> {\n  new (...args: any[]): T;\n}\nexport type Parser = (\n  response: Response,\n) => Promise<unknown> | ReadableStream<any>;\nexport type OutputType =\n  | Type<APIResponse>\n  | { parser: Parser; type: Type<APIResponse> };\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function parse<T extends OutputType[], R = ResponseData<T>>(\n  outputs: T,\n  response: Response,\n  mapper: ResponseMapper<T, R>,\n) {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of outputs) {\n    if ('parser' in outputType) {\n      parser = outputType.parser;\n      if (isTypeOf(outputType.type, APIResponse)) {\n        if (response.status === outputType.type.status) {\n          output = outputType.type;\n          break;\n        }\n      }\n    } else if (isTypeOf(outputType, APIResponse)) {\n      if (response.status === outputType.status) {\n        output = outputType;\n        break;\n      }\n    }\n  }\n\n  if (response.ok) {\n    const apiresponse = (output || APIResponse).create(\n      response.status,\n      response.headers,\n      mapper((await parser(response)) as ResponseData<T>),\n    );\n\n    return apiresponse as RebindSuccessPayload<Extract<InstanceType<T>, SuccessfulResponse<unknown>>, R>;\n  }\n\n  throw (output || APIError).create(\n    response.status,\n    response.headers,\n    await parser(response),\n  );\n}\n\nexport function isTypeOf<T extends Type<APIResponse>>(\n  instance: any,\n  baseType: T,\n): instance is T {\n  if (instance === baseType) {\n    return true;\n  }\n  const prototype = Object.getPrototypeOf(instance);\n  if (prototype === null) {\n    return false;\n  }\n  return isTypeOf(prototype, baseType);\n}\n\nexport class Dispatcher {\n  #interceptors: Interceptor[] = [];\n  #fetch: z.infer<typeof fetchType>;\n  constructor(interceptors: Interceptor[], fetch?: z.infer<typeof fetchType>) {\n    this.#interceptors = interceptors;\n    this.#fetch = fetch;\n  }\n\n  async send<T extends OutputType[], R = ResponseData<T>>(\n    config: RequestConfig,\n    outputs: T,\n    signal?: AbortSignal,\n    mapper?: ResponseMapper<T, R>,\n  ) {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor.before) {\n        config = await interceptor.before(config);\n      }\n    }\n\n    let response = await (this.#fetch ?? fetch)(\n      new Request(config.url, config.init),\n      {\n        ...config.init,\n        signal: signal,\n      },\n    );\n\n    for (let i = this.#interceptors.length - 1; i >= 0; i--) {\n      const interceptor = this.#interceptors[i];\n      if (interceptor.after) {\n        response = await interceptor.after(response.clone());\n      }\n    }\n\n    return await parse(\n      outputs,\n      response,\n      mapper ?? ((data: ResponseData<T>) => data as unknown as R),\n    );\n  }\n}\n";
+var dispatcher_default = "export type Unionize<T> = T extends [infer Single extends OutputType]\n  ? InstanceType<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: InstanceType<Tuple[I]> }[number]\n    : never;\n\nexport type InstanceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends { type: Type<infer U> }\n      ? U\n      : T extends Array<unknown>\n        ? Unionize<T>\n        : never;\n\ntype ResponseData<T extends OutputType[]> =\n  Extract<InstanceType<T>, SuccessfulResponse> extends SuccessfulResponse<\n    infer P\n  >\n    ? P\n    : unknown;\n\ntype ResponseMapper<T extends OutputType[], R> = (data: ResponseData<T>) => R;\n\nexport interface Type<T> {\n  new (...args: any[]): T;\n}\nexport type Parser = (\n  response: Response,\n) => Promise<unknown> | ReadableStream<any> | SSEListener;\nexport type OutputType =\n  | Type<APIResponse>\n  | { parser: Parser; type: Type<APIResponse> };\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function parse<T extends OutputType[], R = ResponseData<T>>(\n  outputs: T,\n  response: Response,\n  mapper: ResponseMapper<T, R>,\n) {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of outputs) {\n    if ('parser' in outputType) {\n      parser = outputType.parser;\n      if (isTypeOf(outputType.type, APIResponse)) {\n        if (response.status === outputType.type.status) {\n          output = outputType.type;\n          break;\n        }\n      }\n    } else if (isTypeOf(outputType, APIResponse)) {\n      if (response.status === outputType.status) {\n        output = outputType;\n        break;\n      }\n    }\n  }\n\n  if (response.ok) {\n    const apiresponse = (output || APIResponse).create(\n      response.status,\n      response.headers,\n      mapper((await parser(response)) as ResponseData<T>),\n    );\n\n    return apiresponse as RebindSuccessPayload<Extract<InstanceType<T>, SuccessfulResponse<unknown>>, R>;\n  }\n\n  throw (output || APIError).create(\n    response.status,\n    response.headers,\n    await parser(response),\n  );\n}\n\nexport function isTypeOf<T extends Type<APIResponse>>(\n  instance: any,\n  baseType: T,\n): instance is T {\n  if (instance === baseType) {\n    return true;\n  }\n  const prototype = Object.getPrototypeOf(instance);\n  if (prototype === null) {\n    return false;\n  }\n  return isTypeOf(prototype, baseType);\n}\n\nexport class Dispatcher {\n  #interceptors: Interceptor[] = [];\n  #fetch: z.infer<typeof fetchType>;\n  constructor(interceptors: Interceptor[], fetch?: z.infer<typeof fetchType>) {\n    this.#interceptors = interceptors;\n    this.#fetch = fetch;\n  }\n\n  async send<T extends OutputType[], R = ResponseData<T>>(\n    config: RequestConfig,\n    outputs: T,\n    signal?: AbortSignal,\n    mapper?: ResponseMapper<T, R>,\n  ) {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor.before) {\n        config = await interceptor.before(config);\n      }\n    }\n\n    let response = await (this.#fetch ?? fetch)(\n      new Request(config.url, config.init),\n      {\n        ...config.init,\n        signal: signal,\n      },\n    );\n\n    for (let i = this.#interceptors.length - 1; i >= 0; i--) {\n      const interceptor = this.#interceptors[i];\n      if (interceptor.after) {\n        response = await interceptor.after(response.clone());\n      }\n    }\n\n    return await parse(\n      outputs,\n      response,\n      mapper ?? ((data: ResponseData<T>) => data as unknown as R),\n    );\n  }\n}\n";
 
 // packages/typescript/src/lib/http/interceptors.txt
 var interceptors_default = "export interface Interceptor {\n  before?: (config: RequestConfig) => Promise<RequestConfig> | RequestConfig;\n  after?: (response: Response) => Promise<Response> | Response;\n}\n\nexport const createHeadersInterceptor = (\n  headers: Record<string, string | undefined>,\n  requestHeaders: HeadersInit,\n):Interceptor => {\n  return {\n    before({init, url}) {\n      // Priority Levels\n      // 1. Headers Input\n      // 2. Request Headers\n      // 3. Default Headers\n\n      for (const [key, value] of new Headers(requestHeaders)) {\n        // Only set the header if it doesn't already exist and has a value\n        // even though these headers are passed at operation level\n        // still they are lower priority compared to the headers input\n        if (value !== undefined && !init.headers.has(key)) {\n          init.headers.set(key, value);\n        }\n      }\n\n      for (const [key, value] of Object.entries(headers)) {\n        // Only set the header if it doesn't already exist and has a value\n        if (value !== undefined && !init.headers.has(key)) {\n          init.headers.set(key, value);\n        }\n      }\n\n      return {init, url};\n    },\n  };\n};\n\nexport const createBaseUrlInterceptor = (baseUrl: string): Interceptor => {\n  return {\n    before({ init, url }) {\n      if (url.protocol === 'local:') {\n        return {\n          init,\n          url: new URL(url.href.replace('local://', baseUrl))\n        };\n      }\n      return { init, url };\n    },\n  };\n};\n\nexport const logInterceptor: Interceptor = {\n  before({ url, init }) {\n    console.log('Request:', { url, init });\n    return { url, init };\n  },\n  after(response) {\n    console.log('Response:', response);\n    return response;\n  },\n};\n\n/**\n * Creates an interceptor that logs detailed information about requests and responses.\n * @param options Configuration options for the logger\n * @returns An interceptor object with before and after handlers\n */\nexport const createDetailedLogInterceptor = (options?: {\n  logLevel?: 'debug' | 'info' | 'warn' | 'error';\n  includeRequestBody?: boolean;\n  includeResponseBody?: boolean;\n}) => {\n  const logLevel = options?.logLevel || 'info';\n  const includeRequestBody = options?.includeRequestBody || false;\n  const includeResponseBody = options?.includeResponseBody || false;\n\n  return {\n    async before(request: Request) {\n      const logData = {\n        url: request.url,\n        method: request.method,\n        contentType: request.headers.get('Content-Type'),\n        headers: Object.fromEntries([...request.headers.entries()]),\n      };\n\n      console[logLevel]('\u{1F680} Outgoing Request:', logData);\n\n      if (includeRequestBody) {\n        try {\n          // Clone the request to avoid consuming the body stream\n          const clonedRequest = request.clone();\n          if (clonedRequest.headers.get('Content-Type')?.includes('application/json')) {\n            const body = await clonedRequest.json().catch(() => null);\n            console[logLevel]('Request Body:', body);\n          } else {\n            const body = await clonedRequest.text().catch(() => null);\n            console[logLevel]('Request Body:', body);\n          }\n        } catch (error) {\n          console.error('Could not log request body:', error);\n        }\n      }\n\n      return request;\n    },\n\n    async after(response: Response) {\n      const logData = {\n        status: response.status,\n        statusText: response.statusText,\n        url: response.url,\n        headers: Object.fromEntries([...response.headers.entries()]),\n      };\n\n      console[logLevel]('\u{1F4E5} Incoming Response:', logData);\n\n      if (includeResponseBody && response.body) {\n        try {\n          // Clone the response to avoid consuming the body stream\n          const clonedResponse = response.clone();\n          if (clonedResponse.headers.get('Content-Type')?.includes('application/json')) {\n            const body = await clonedResponse.json().catch(() => null);\n            console[logLevel]('Response Body:', body);\n          } else {\n            const body = await clonedResponse.text().catch(() => null);\n            if (body) {\n              console[logLevel]('Response Body:', body.substring(0, 500) + (body.length > 500 ? '...' : ''));\n            } else {\n              console[logLevel]('No response body');\n            }\n          }\n        } catch (error) {\n          console.error('Could not log response body:', error);\n        }\n      }\n\n      return response;\n    },\n  };\n};\n";
 
 // packages/typescript/src/lib/http/parse-response.txt
-var parse_response_default = 'import { parse } from "fast-content-type-parse";\n\nasync function handleChunkedResponse(response: Response, contentType: string) {\n	const { type } = parse(contentType);\n\n	switch (type) {\n		case "application/json": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return JSON.parse(buffer);\n		}\n		case "text/html":\n		case "text/plain": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return buffer;\n		}\n		default:\n			return response.body;\n	}\n}\n\nexport function chunked(response: Response) {\n	return response.body!;\n}\n\nexport async function buffered(response: Response) {\n	const contentType = response.headers.get("Content-Type");\n	if (!contentType) {\n		throw new Error("Content-Type header is missing");\n	}\n\n	if (response.status === 204) {\n		return null;\n	}\n\n	const { type } = parse(contentType);\n	switch (type) {\n		case "application/json":\n			return response.json();\n		case "text/plain":\n			return response.text();\n		case "text/html":\n			return response.text();\n		case "text/xml":\n		case "application/xml":\n			return response.text();\n		case "application/x-www-form-urlencoded": {\n			const text = await response.text();\n			return Object.fromEntries(new URLSearchParams(text));\n		}\n		case "multipart/form-data":\n			return response.formData();\n		default:\n			throw new Error(`Unsupported content type: ${contentType}`);\n	}\n}\n';
+var parse_response_default = 'import { parse } from "fast-content-type-parse";\n\nfunction isBinaryContentType(contentType: string) {\n	const type = contentType.toLowerCase();\n	if (type.startsWith("image/")) {\n		return true;\n	}\n	if (type.startsWith("audio/")) {\n		return true;\n	}\n	if (type.startsWith("video/")) {\n		return true;\n	}\n	switch (type) {\n		case "application/pdf":\n		case "application/zip":\n		case "application/gzip":\n		case "application/x-7z-compressed":\n		case "application/x-tar":\n		case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":\n		case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":\n		case "application/vnd.openxmlformats-officedocument.presentationml.presentation":\n		case "application/vnd.ms-excel":\n		case "application/vnd.ms-powerpoint":\n		case "application/msword":\n		case "application/octet-stream":\n			return true;\n		default:\n			return false;\n	}\n}\n\nasync function handleChunkedResponse(response: Response, contentType: string) {\n	const { type } = parse(contentType);\n\n	switch (type) {\n		case "application/json": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return JSON.parse(buffer);\n		}\n		case "text/html":\n		case "text/plain": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return buffer;\n		}\n		default:\n			return response.body;\n	}\n}\n\nexport function chunked(response: Response) {\n	return response.body!;\n}\n\nexport async function buffered(response: Response) {\n	const contentType = response.headers.get("Content-Type");\n	if (!contentType) {\n		throw new Error("Content-Type header is missing");\n	}\n\n	if (response.status === 204) {\n		return null;\n	}\n\n	const { type } = parse(contentType);\n	if (isBinaryContentType(type)) {\n		return response.blob();\n	}\n	if (type.startsWith("text/")) {\n		return response.text();\n	}\n	switch (type) {\n		case "application/json":\n			return response.json();\n		case "application/xml":\n			return response.text();\n		case "application/x-www-form-urlencoded": {\n			const text = await response.text();\n			return Object.fromEntries(new URLSearchParams(text));\n		}\n		case "multipart/form-data":\n			return response.formData();\n		default:\n			throw new Error(`Unsupported content type: ${contentType}`);\n	}\n}\n';
 
 // packages/typescript/src/lib/http/parser.txt
 var parser_default = "import { z } from 'zod';\n\nexport class ParseError<T extends z.ZodType<any, any, any>> extends Error {\n  public data: z.typeToFlattenedError<T, z.ZodIssue>;\n  constructor(data: z.typeToFlattenedError<T, z.ZodIssue>) {\n    super('Validation failed');\n    this.name = 'ParseError';\n    this.data = data;\n  }\n}\n\nexport function parseInput<T extends z.ZodType<any, any, any>>(\n  schema: T,\n  input: unknown,\n): z.infer<T> {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const error = result.error.flatten((issue) => issue);\n    throw new ParseError(error);\n  }\n  return result.data as z.infer<T>;\n}\n";
@@ -1253,6 +1327,9 @@ var request_default = "type Init = Omit<RequestInit, 'headers'> & { headers: Hea
 // packages/typescript/src/lib/http/response.txt
 var response_default = "export class APIResponse<Body = unknown, Status extends number = number> {\n  static readonly status: number;\n  readonly status: Status;\n  data: Body;\n  readonly headers: Headers;\n\n  constructor(status: Status, headers: Headers, data: Body) {\n    this.status = status;\n    this.headers = headers;\n    this.data = data;\n  }\n\n  static create<Body = unknown>(status: number, headers: Headers, data: Body) {\n    return new this(status, headers, data);\n  }\n}\n\nexport class APIError<Body, Status extends number = number> extends APIResponse<\n  Body,\n  Status\n> {\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(status, headers, data);\n  }\n}\n\n// 2xx Success\nexport class Ok<T> extends APIResponse<T, 200> {\n  static override readonly status = 200 as const;\n  constructor(headers: Headers, data: T) {\n    super(Ok.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\n\nexport class Created<T> extends APIResponse<T, 201> {\n  static override status = 201 as const;\n  constructor(headers: Headers, data: T) {\n    super(Created.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Accepted<T> extends APIResponse<T, 202> {\n  static override status = 202 as const;\n  constructor(headers: Headers, data: T) {\n    super(Accepted.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NoContent extends APIResponse<never, 204> {\n  static override status = 204 as const;\n  constructor(headers: Headers) {\n    super(NoContent.status, headers, null as never);\n  }\n  static override create(status: number, headers: Headers): NoContent {\n    return new this(headers);\n  }\n}\n\n// 4xx Client Errors\nexport class BadRequest<T> extends APIError<T, 400> {\n  static override status = 400 as const;\n  constructor(headers: Headers, data: T) {\n    super(BadRequest.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Unauthorized<T = { message: string }> extends APIError<T, 401> {\n  static override status = 401 as const;\n  constructor(headers: Headers, data: T) {\n    super(Unauthorized.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class PaymentRequired<T = { message: string }> extends APIError<T, 402> {\n  static override status = 402 as const;\n  constructor(headers: Headers, data: T) {\n    super(PaymentRequired.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Forbidden<T = { message: string }> extends APIError<T, 403> {\n  static override status = 403 as const;\n  constructor(headers: Headers, data: T) {\n    super(Forbidden.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NotFound<T = { message: string }> extends APIError<T, 404> {\n  static override status = 404 as const;\n  constructor(headers: Headers, data: T) {\n    super(NotFound.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class MethodNotAllowed<T = { message: string }> extends APIError<\n  T,\n  405\n> {\n  static override status = 405 as const;\n  constructor(headers: Headers, data: T) {\n    super(MethodNotAllowed.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NotAcceptable<T = { message: string }> extends APIError<T, 406> {\n  static override status = 406 as const;\n  constructor(headers: Headers, data: T) {\n    super(NotAcceptable.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Conflict<T = { message: string }> extends APIError<T, 409> {\n  static override status = 409 as const;\n  constructor(headers: Headers, data: T) {\n    super(Conflict.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Gone<T = { message: string }> extends APIError<T, 410> {\n  static override status = 410 as const;\n  constructor(headers: Headers, data: T) {\n    super(Gone.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class PreconditionFailed<T = { message: string }> extends APIError<\n  T,\n  412\n> {\n  static override status = 412 as const;\n  constructor(headers: Headers, data: T) {\n    super(PreconditionFailed.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class UnprocessableEntity<\n  T = { message: string; errors?: Record<string, string[]> },\n> extends APIError<T, 422> {\n  static override status = 422 as const;\n  constructor(headers: Headers, data: T) {\n    super(UnprocessableEntity.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class TooManyRequests<\n  T = { message: string; retryAfter?: string },\n> extends APIError<T, 429> {\n  static override status = 429 as const;\n  constructor(headers: Headers, data: T) {\n    super(TooManyRequests.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class PayloadTooLarge<T = { message: string }> extends APIError<T, 413> {\n  static override status = 413 as const;\n  constructor(headers: Headers, data: T) {\n    super(PayloadTooLarge.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class UnsupportedMediaType<T = { message: string }> extends APIError<\n  T,\n  415\n> {\n  static override status = 415 as const;\n  constructor(headers: Headers, data: T) {\n    super(UnsupportedMediaType.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\n\n// 5xx Server Errors\nexport class InternalServerError<T = { message: string }> extends APIError<\n  T,\n  500\n> {\n  static override status = 500 as const;\n  constructor(headers: Headers, data: T) {\n    super(InternalServerError.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NotImplemented<T = { message: string }> extends APIError<T, 501> {\n  static override status = 501 as const;\n  constructor(headers: Headers, data: T) {\n    super(NotImplemented.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class BadGateway<T = { message: string }> extends APIError<T, 502> {\n  static override status = 502 as const;\n  constructor(headers: Headers, data: T) {\n    super(BadGateway.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class ServiceUnavailable<\n  T = { message: string; retryAfter?: string },\n> extends APIError<T, 503> {\n  static override status = 503 as const;\n  constructor(headers: Headers, data: T) {\n    super(ServiceUnavailable.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class GatewayTimeout<T = { message: string }> extends APIError<T, 504> {\n  static override status = 504 as const;\n  constructor(headers: Headers, data: T) {\n    super(GatewayTimeout.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\n\nexport type ClientError =\n  | BadRequest<unknown>\n  | Unauthorized<unknown>\n  | PaymentRequired<unknown>\n  | Forbidden<unknown>\n  | NotFound<unknown>\n  | MethodNotAllowed<unknown>\n  | NotAcceptable<unknown>\n  | Conflict<unknown>\n  | Gone<unknown>\n  | PreconditionFailed<unknown>\n  | PayloadTooLarge<unknown>\n  | UnsupportedMediaType<unknown>\n  | UnprocessableEntity<unknown>\n  | TooManyRequests<unknown>;\n\nexport type ServerError =\n  | InternalServerError<unknown>\n  | NotImplemented<unknown>\n  | BadGateway<unknown>\n  | ServiceUnavailable<unknown>\n  | GatewayTimeout<unknown>;\n\nexport type ProblematicResponse = ClientError | ServerError;\n\nexport type SuccessfulResponse<T = unknown> =\n  | Ok<T>\n  | Created<T>\n  | Accepted<T>\n  | NoContent;\n\nexport type RebindSuccessPayload<Resp, New> =\n  Resp extends Ok<infer _>\n    ? Ok<New>\n    : Resp extends Created<infer _>\n      ? Created<New>\n      : Resp extends Accepted<infer _>\n        ? Accepted<New>\n        : Resp extends NoContent\n          ? NoContent\n          : Resp extends SuccessfulResponse<infer _>\n            ? APIResponse<New, Resp['status']>\n            : never;\n";
 
+// packages/typescript/src/lib/http/sse.txt
+var sse_default = 'export type SSEListener = (eventType: string) => AsyncIterable<string>;\n\nexport function sse(response: Response): SSEListener {\n	const subscribers = new Map<\n		string,\n		{ queue: string[]; resolve: (() => void) | null }\n	>();\n	let started = false;\n	let streamDone = false;\n\n	function dispatch(eventType: string, data: string) {\n		const sub = subscribers.get(eventType);\n		if (sub) {\n			sub.queue.push(data);\n			sub.resolve?.();\n			sub.resolve = null;\n		}\n	}\n\n	function endAll() {\n		streamDone = true;\n		for (const sub of subscribers.values()) {\n			sub.resolve?.();\n		}\n	}\n\n	function startReading() {\n		if (started) return;\n		started = true;\n		const decoder = new TextDecoder();\n		let buffer = "";\n\n		(async () => {\n			try {\n				for await (const value of response.body!) {\n					buffer += decoder.decode(value, { stream: true });\n					const parts = buffer.split("\\n\\n");\n					buffer = parts.pop()!;\n\n					for (const part of parts) {\n						if (!part.trim()) continue;\n						let eventType = "message";\n						let data = "";\n						for (const line of part.split("\\n")) {\n							if (line.startsWith("event:")) {\n								eventType = line.slice(6).trim();\n							} else if (line.startsWith("data:")) {\n								data += (data ? "\\n" : "") + line.slice(5).trim();\n							}\n						}\n						if (data) dispatch(eventType, data);\n					}\n				}\n			} catch {}\n			endAll();\n		})();\n	}\n\n	return function listen(eventType: string): AsyncIterable<string> {\n		if (!subscribers.has(eventType)) {\n			subscribers.set(eventType, { queue: [], resolve: null });\n		}\n		const sub = subscribers.get(eventType)!;\n		startReading();\n\n		return {\n			[Symbol.asyncIterator]() {\n				return {\n					async next(): Promise<IteratorResult<string>> {\n						while (sub.queue.length === 0) {\n							if (streamDone) return { value: undefined as any, done: true };\n							const { promise, resolve } = Promise.withResolvers<void>();\n							sub.resolve = resolve;\n							await promise;\n						}\n						return { value: sub.queue.shift()!, done: false };\n					},\n					async return(): Promise<IteratorResult<string>> {\n						return { value: undefined as any, done: true };\n					},\n				};\n			},\n		};\n	};\n}\n';
+
 // packages/typescript/src/lib/paginations/cursor-pagination.txt
 var cursor_pagination_default = "type CursorPaginationParams = {\n  cursor?: string;\n};\n\ninterface CursorMetadata extends Metadata {\n  nextCursor?: string;\n}\n\ninterface Metadata {\n  hasMore?: boolean;\n}\n\ntype PaginationResult<T, M extends CursorMetadata> = {\n  data: T[];\n  meta: M;\n};\n\ntype FetchFn<T, M extends CursorMetadata> = (\n  input: CursorPaginationParams,\n) => Promise<PaginationResult<T, M>>;\n\n/**\n * @experimental\n */\nexport class CursorPagination<T, M extends CursorMetadata> {\n  #meta: PaginationResult<T, M>['meta'] | null = null;\n  #params: CursorPaginationParams;\n  #currentPage: Page<T> | null = null;\n  readonly #fetchFn: FetchFn<T, M>;\n\n  constructor(\n    initialParams: PartialNullable<CursorPaginationParams>,\n    fetchFn: FetchFn<T, M>,\n  ) {\n    this.#fetchFn = fetchFn;\n    this.#params = {\n      cursor: initialParams.cursor ?? undefined,\n    };\n  }\n\n  async getNextPage() {\n    const result = await this.#fetchFn(this.#params);\n    this.#currentPage = new Page(result.data);\n    this.#meta = result.meta;\n    this.#params = {\n      ...this.#params,\n      cursor: result.meta.nextCursor,\n    };\n    return this;\n  }\n\n  getCurrentPage() {\n    if (!this.#currentPage) {\n      throw new Error(\n        'No page data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#currentPage;\n  }\n\n  get hasMore() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta.hasMore;\n  }\n\n  async *[Symbol.asyncIterator]() {\n    for await (const page of this.iter()) {\n      yield page.getCurrentPage();\n    }\n  }\n\n  async *iter() {\n    if (!this.#currentPage) {\n      yield await this.getNextPage();\n    }\n\n    while (this.hasMore) {\n      yield await this.getNextPage();\n    }\n  }\n\n  get metadata() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta;\n  }\n}\n\nclass Page<T> {\n  data: T[];\n  constructor(data: T[]) {\n    this.data = data;\n  }\n}\n\ntype PartialNullable<T> = {\n  [K in keyof T]?: T[K] | null;\n};\n";
 
@@ -1647,6 +1724,32 @@ ${l}`));
   return markdown.join("\n\n");
 }
 
+// packages/typescript/src/lib/server-urls.ts
+function expandServerUrls(servers) {
+  return servers.flatMap((server) => {
+    const variables = server.variables;
+    if (!variables || Object.keys(variables).length === 0) {
+      return [server.url];
+    }
+    const entries = Object.entries(variables);
+    const valueSets = entries.map(([, variable]) => {
+      const enumValues = variable.enum?.map(String);
+      return enumValues?.length ? enumValues : [String(variable.default)];
+    });
+    const combinations = valueSets.reduce(
+      (acc, values) => acc.flatMap((combo) => values.map((v) => [...combo, v])),
+      [[]]
+    );
+    return combinations.map((combo) => {
+      let url = server.url;
+      for (let i = 0; i < entries.length; i++) {
+        url = url.replaceAll(`{${entries[i][0]}}`, combo[i]);
+      }
+      return url;
+    });
+  });
+}
+
 // packages/typescript/src/lib/typescript-snippet.ts
 import { camelcase as camelcase5, spinalcase as spinalcase3 } from "stringcase";
 import { isEmpty as isEmpty4, pascalcase as pascalcase4, resolveRef as resolveRef3 } from "@sdk-it/core";
@@ -2000,7 +2103,7 @@ var TypeScriptSnippet = class {
   }
   client() {
     const options = {
-      baseUrl: this.#spec.servers?.[0]?.url ?? "http://localhost:3000"
+      baseUrl: expandServerUrls(this.#spec.servers ?? [])[0] ?? "http://localhost:3000"
     };
     const authOptions = this.#authentication();
     if (!isEmpty4(authOptions)) {
@@ -2041,7 +2144,7 @@ ${client.use}`;
     const hasServers = Boolean(
       this.#spec.servers && this.#spec.servers.length > 0
     );
-    const baseUrl = this.#spec.servers?.[0]?.url || "https://api.example.com";
+    const baseUrl = expandServerUrls(this.#spec.servers ?? [])[0] || "https://api.example.com";
     const authOptions = this.#authentication();
     const hasApiKey = !isEmpty4(authOptions);
     sections.push("### Configuration Options");
@@ -2457,7 +2560,7 @@ ${client.use}`;
         );
         sections.push("");
         const bearerAuthClient = this.#constructClient({
-          [optionName]: "sk_live_51234567890abcdef1234567890abcdef"
+          [optionName]: "test_51234567890abcdef1234567890abcdef"
         });
         sections.push(createCodeBlock("typescript", [bearerAuthClient.use]));
         sections.push("");
@@ -2466,7 +2569,7 @@ ${client.use}`;
         sections.push(`${headingLevel} ${apiKeyHeading}`);
         sections.push("");
         const apiKeyAuthClient = this.#constructClient({
-          [optionName]: "api_key_1234567890abcdef1234567890abcdef"
+          [optionName]: "test_api_key_1234567890abcdef1234567890abcdef"
         });
         sections.push(createCodeBlock("typescript", [apiKeyAuthClient.use]));
         sections.push("");
@@ -2475,7 +2578,7 @@ ${client.use}`;
         sections.push(`${headingLevel} ${queryParamHeading}`);
         sections.push("");
         const queryParamAuthClient = this.#constructClient({
-          [optionName]: "qp_key_1234567890abcdef1234567890abcdef"
+          [optionName]: "test_qp_key_1234567890abcdef1234567890abcdef"
         });
         sections.push(
           createCodeBlock("typescript", [queryParamAuthClient.use])
@@ -2486,7 +2589,7 @@ ${client.use}`;
         sections.push(`${headingLevel} ${genericAuthHeading}`);
         sections.push("");
         const genericAuthClient = this.#constructClient({
-          [optionName]: "auth_token_1234567890abcdef1234567890abcdef"
+          [optionName]: "test_auth_token_1234567890abcdef1234567890abcdef"
         });
         sections.push(createCodeBlock("typescript", [genericAuthClient.use]));
         sections.push("");
@@ -2513,7 +2616,7 @@ ${client.use}`;
     if (!isEmpty4(authOptions)) {
       const [primaryAuth] = authOptions;
       const authOptionName = primaryAuth["x-optionName"] ?? primaryAuth.name;
-      initialClientOptions[authOptionName] = "prod_sk_1234567890abcdef";
+      initialClientOptions[authOptionName] = "YOUR_PRODUCTION_TOKEN";
     }
     const initialClientSetup = this.#constructClient(initialClientOptions);
     const configurationUpdateCode = [
@@ -2527,9 +2630,7 @@ ${client.use}`;
     if (!isEmpty4(authOptions)) {
       const [primaryAuth] = authOptions;
       const authOptionName = primaryAuth["x-optionName"] ?? primaryAuth.name;
-      configurationUpdateCode.push(
-        `  ${authOptionName}: 'staging_sk_abcdef1234567890'`
-      );
+      configurationUpdateCode.push(`  ${authOptionName}: 'YOUR_STAGING_TOKEN'`);
     }
     configurationUpdateCode.push("});");
     sections.push(createCodeBlock("typescript", configurationUpdateCode));
@@ -2634,7 +2735,7 @@ async function generate(openapi, settings) {
     makeImport
   });
   const clientName = pascalcase5((settings.name || "client").trim());
-  const packageName = settings.name ? `@${spinalcase4(settings.name.trim().toLowerCase())}/sdk` : "sdk";
+  const packageName = settings.packageName ?? (settings.name ? `@${spinalcase4(settings.name.trim().toLowerCase())}/sdk` : "sdk");
   const inputs = toInputs(groups, commonZod, makeImport);
   const models = serializeModels(spec);
   await settings.writer(output, {
@@ -2647,10 +2748,12 @@ async function generate(openapi, settings) {
     "response.ts": response_default,
     "parser.ts": parser_default,
     "request.ts": request_default,
+    "sse.ts": sse_default,
     "dispatcher.ts": `import z from 'zod';
 import { type Interceptor } from '${makeImport("../http/interceptors")}';
 import { type RequestConfig } from '${makeImport("../http/request")}';
 import { buffered } from '${makeImport("./parse-response")}';
+import { type SSEListener } from '${makeImport("./sse")}';
 import { APIError, APIResponse, type SuccessfulResponse, type RebindSuccessPayload } from '${makeImport("./response")}';
 
 ${template2(dispatcher_default, {})()}`,
@@ -2661,7 +2764,7 @@ ${template2(dispatcher_default, {})()}`,
   await settings.writer(output, {
     "client.ts": client_default({
       name: clientName,
-      servers: (spec.servers ?? []).map((server) => server.url) || [],
+      servers: expandServerUrls(spec.servers ?? []),
       options: security(spec),
       makeImport
     }),
@@ -2821,6 +2924,7 @@ ${utils_default}`
     output,
     env: npmRunPathEnv()
   });
+  return { packageName };
 }
 function serializeModels(spec) {
   const filesMap = {};
@@ -2834,12 +2938,18 @@ function serializeModels(spec) {
       continue;
     }
     const folder = isResponseBody ? "outputs" : "models";
-    let typeContent = "ReadableStream";
+    const isSse = schema["x-sse"];
+    let typeContent = isSse ? "SSEListener" : "ReadableStream";
     if (!stream) {
       const serializer = new TypeScriptEmitter(spec);
       typeContent = serializer.handle(schema, true);
     }
+    const imports = [];
+    if (isSse) {
+      imports.push(`import type { SSEListener } from '../http/sse.ts';`);
+    }
     const fileContent = [
+      ...imports,
       `
 ${schema.description ? `
 /**