@richie-rpc/client 1.2.3 → 1.2.5

package/dist/cjs/websocket.cjs

@@ -0,0 +1,178 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/client/websocket.ts
+var exports_websocket = {};
+__export(exports_websocket, {
+  createWebSocketClient: () => createWebSocketClient,
+  WebSocketClientValidationError: () => WebSocketClientValidationError
+});
+module.exports = __toCommonJS(exports_websocket);
+var import_core = require("@richie-rpc/core");
+
+class WebSocketClientValidationError extends Error {
+  messageType;
+  issues;
+  constructor(messageType, issues) {
+    super(`Validation failed for WebSocket message type: ${messageType}`);
+    this.messageType = messageType;
+    this.issues = issues;
+    this.name = "WebSocketClientValidationError";
+  }
+}
+function createTypedWebSocket(endpoint, url) {
+  let ws = null;
+  let isConnected = false;
+  const messageListeners = new Set;
+  const typedListeners = {};
+  const stateListeners = new Set;
+  const errorListeners = new Set;
+  for (const type of Object.keys(endpoint.serverMessages)) {
+    typedListeners[type] = new Set;
+  }
+  function notifyStateChange(connected) {
+    isConnected = connected;
+    stateListeners.forEach((h) => h(connected));
+  }
+  function notifyError(error) {
+    errorListeners.forEach((h) => h(error));
+  }
+  function handleMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      messageListeners.forEach((h) => h(message));
+      const { type, payload } = message;
+      if (typedListeners[type]) {
+        typedListeners[type].forEach((h) => h(payload));
+      }
+    } catch (err) {
+      notifyError(new Error(`Failed to parse WebSocket message: ${err.message}`));
+    }
+  }
+  return {
+    connect() {
+      if (ws) {
+        return () => {
+          ws?.close();
+          ws = null;
+        };
+      }
+      ws = new WebSocket(url);
+      ws.onopen = () => {
+        notifyStateChange(true);
+      };
+      ws.onclose = () => {
+        notifyStateChange(false);
+        ws = null;
+      };
+      ws.onerror = () => {
+        notifyError(new Error("WebSocket connection error"));
+      };
+      ws.onmessage = handleMessage;
+      return () => {
+        ws?.close();
+        ws = null;
+      };
+    },
+    send(type, payload) {
+      if (!ws || ws.readyState !== WebSocket.OPEN) {
+        throw new Error("WebSocket is not connected");
+      }
+      const messageDef = endpoint.clientMessages[type];
+      if (messageDef && messageDef.payload) {
+        const result = messageDef.payload.safeParse(payload);
+        if (!result.success) {
+          throw new WebSocketClientValidationError(type, result.error.issues);
+        }
+      }
+      ws.send(JSON.stringify({ type, payload }));
+    },
+    on(type, handler) {
+      const typeStr = type;
+      if (!typedListeners[typeStr]) {
+        typedListeners[typeStr] = new Set;
+      }
+      typedListeners[typeStr].add(handler);
+      return () => typedListeners[typeStr]?.delete(handler);
+    },
+    onMessage(handler) {
+      messageListeners.add(handler);
+      return () => messageListeners.delete(handler);
+    },
+    onStateChange(handler) {
+      stateListeners.add(handler);
+      return () => stateListeners.delete(handler);
+    },
+    onError(handler) {
+      errorListeners.add(handler);
+      return () => errorListeners.delete(handler);
+    },
+    get connected() {
+      return isConnected;
+    }
+  };
+}
+function resolveWebSocketUrl(baseUrl) {
+  if (baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://")) {
+    return baseUrl;
+  }
+  if (baseUrl.startsWith("http://")) {
+    return `ws://${baseUrl.slice(7)}`;
+  }
+  if (baseUrl.startsWith("https://")) {
+    return `wss://${baseUrl.slice(8)}`;
+  }
+  if (baseUrl.startsWith("/")) {
+    const g = globalThis;
+    if (g?.location) {
+      const protocol = g.location.protocol === "https:" ? "wss:" : "ws:";
+      return `${protocol}//${g.location.host}${baseUrl}`;
+    }
+    return `ws://localhost${baseUrl}`;
+  }
+  return `ws://${baseUrl}`;
+}
+function createWebSocketClient(contract, config) {
+  const resolvedBaseUrl = resolveWebSocketUrl(config.baseUrl);
+  const client = {};
+  for (const [name, endpoint] of Object.entries(contract)) {
+    client[name] = (options = {}) => {
+      let path = endpoint.path;
+      if (options.params) {
+        path = import_core.interpolatePath(path, options.params);
+      }
+      const url = import_core.buildUrl(resolvedBaseUrl, path, options.query);
+      return createTypedWebSocket(endpoint, url);
+    };
+  }
+  return client;
+}
+})
+
+//# debugId=15DE3AD0993419A564756E2164756E21

package/dist/cjs/websocket.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../websocket.ts"],
+  "sourcesContent": [
+    "/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  ExtractClientMessagePayload,\n  ExtractServerMessage,\n  ExtractServerMessagePayload,\n  ExtractWSHeaders,\n  ExtractWSParams,\n  ExtractWSQuery,\n  WebSocketContract,\n  WebSocketContractDefinition,\n} from '@richie-rpc/core';\nimport { buildUrl, interpolatePath } from '@richie-rpc/core';\n\n/**\n * Validation error for WebSocket messages\n */\nexport class WebSocketClientValidationError extends Error {\n  constructor(\n    public messageType: string,\n    public issues: unknown[],\n  ) {\n    super(`Validation failed for WebSocket message type: ${messageType}`);\n    this.name = 'WebSocketClientValidationError';\n  }\n}\n\n/**\n * Options for creating a WebSocket connection\n */\nexport type WebSocketConnectionOptions<T extends WebSocketContractDefinition> = {\n  params?: ExtractWSParams<T> extends never ? never : ExtractWSParams<T>;\n  query?: ExtractWSQuery<T> extends never ? never : ExtractWSQuery<T>;\n  headers?: ExtractWSHeaders<T> extends never ? never : ExtractWSHeaders<T>;\n};\n\n/**\n * Typed WebSocket connection interface\n */\nexport interface TypedWebSocket<T extends WebSocketContractDefinition> {\n  /** Connect to WebSocket server, returns disconnect function */\n  connect(): () => void;\n\n  /** Send a typed message (validates before sending) */\n  send<K extends keyof T['clientMessages']>(\n    type: K,\n    payload: ExtractClientMessagePayload<T, K>,\n  ): void;\n\n  /** Subscribe to specific message type, returns unsubscribe function */\n  on<K extends keyof T['serverMessages']>(\n    type: K,\n    handler: (payload: ExtractServerMessagePayload<T, K>) => void,\n  ): () => void;\n\n  /** Subscribe to all messages, returns unsubscribe function */\n  onMessage(handler: (message: ExtractServerMessage<T>) => void): () => void;\n\n  /** Subscribe to connection state changes */\n  onStateChange(handler: (connected: boolean) => void): () => void;\n\n  /** Subscribe to connection errors (network failures, etc.) */\n  onError(handler: (error: Error) => void): () => void;\n\n  /** Current connection state */\n  readonly connected: boolean;\n}\n\n/**\n * WebSocket client type for a contract\n */\nexport type WebSocketClient<T extends WebSocketContract> = {\n  [K in keyof T]: (options?: WebSocketConnectionOptions<T[K]>) => TypedWebSocket<T[K]>;\n};\n\n/**\n * WebSocket client configuration\n */\nexport interface WebSocketClientConfig {\n  /** Base URL for WebSocket connections (ws:// or wss://) */\n  baseUrl: string;\n}\n\n/**\n * Create a typed WebSocket connection for a specific endpoint\n */\nfunction createTypedWebSocket<T extends WebSocketContractDefinition>(\n  endpoint: T,\n  url: string,\n): TypedWebSocket<T> {\n  let ws: WebSocket | null = null;\n  let isConnected = false;\n\n  type MessageHandler = (message: ExtractServerMessage<T>) => void;\n  type TypedHandler<K extends keyof T['serverMessages']> = (\n    payload: ExtractServerMessagePayload<T, K>,\n  ) => void;\n  type StateHandler = (connected: boolean) => void;\n  type ErrorHandler = (error: Error) => void;\n\n  const messageListeners = new Set<MessageHandler>();\n  const typedListeners: Record<string, Set<TypedHandler<any>>> = {};\n  const stateListeners = new Set<StateHandler>();\n  const errorListeners = new Set<ErrorHandler>();\n\n  // Initialize typed listener sets for each server message type\n  for (const type of Object.keys(endpoint.serverMessages)) {\n    typedListeners[type] = new Set();\n  }\n\n  function notifyStateChange(connected: boolean) {\n    isConnected = connected;\n    stateListeners.forEach((h) => h(connected));\n  }\n\n  function notifyError(error: Error) {\n    errorListeners.forEach((h) => h(error));\n  }\n\n  function handleMessage(event: MessageEvent) {\n    try {\n      const message = JSON.parse(event.data) as ExtractServerMessage<T>;\n\n      // Notify all-message listeners\n      messageListeners.forEach((h) => h(message));\n\n      // Notify type-specific listeners\n      const { type, payload } = message as { type: string; payload: unknown };\n      if (typedListeners[type]) {\n        typedListeners[type].forEach((h) => h(payload as any));\n      }\n    } catch (err) {\n      notifyError(new Error(`Failed to parse WebSocket message: ${(err as Error).message}`));\n    }\n  }\n\n  return {\n    connect() {\n      if (ws) {\n        // Already connected or connecting\n        return () => {\n          ws?.close();\n          ws = null;\n        };\n      }\n\n      ws = new WebSocket(url);\n\n      ws.onopen = () => {\n        notifyStateChange(true);\n      };\n\n      ws.onclose = () => {\n        notifyStateChange(false);\n        ws = null;\n      };\n\n      ws.onerror = () => {\n        notifyError(new Error('WebSocket connection error'));\n      };\n\n      ws.onmessage = handleMessage;\n\n      // Return disconnect function\n      return () => {\n        ws?.close();\n        ws = null;\n      };\n    },\n\n    send(type, payload) {\n      if (!ws || ws.readyState !== WebSocket.OPEN) {\n        throw new Error('WebSocket is not connected');\n      }\n\n      // Validate payload against schema\n      const messageDef = endpoint.clientMessages[type as string];\n      if (messageDef && messageDef.payload) {\n        const result = messageDef.payload.safeParse(payload);\n        if (!result.success) {\n          throw new WebSocketClientValidationError(type as string, result.error.issues);\n        }\n      }\n\n      // Send message\n      ws.send(JSON.stringify({ type, payload }));\n    },\n\n    on(type, handler) {\n      const typeStr = type as string;\n      if (!typedListeners[typeStr]) {\n        typedListeners[typeStr] = new Set();\n      }\n      typedListeners[typeStr].add(handler);\n      return () => typedListeners[typeStr]?.delete(handler);\n    },\n\n    onMessage(handler) {\n      messageListeners.add(handler);\n      return () => messageListeners.delete(handler);\n    },\n\n    onStateChange(handler) {\n      stateListeners.add(handler);\n      return () => stateListeners.delete(handler);\n    },\n\n    onError(handler) {\n      errorListeners.add(handler);\n      return () => errorListeners.delete(handler);\n    },\n\n    get connected() {\n      return isConnected;\n    },\n  };\n}\n\n/**\n * Resolve HTTP URL to WebSocket URL\n */\nfunction resolveWebSocketUrl(baseUrl: string): string {\n  // If already a WebSocket URL, return as-is\n  if (baseUrl.startsWith('ws://') || baseUrl.startsWith('wss://')) {\n    return baseUrl;\n  }\n\n  // Convert http:// to ws:// and https:// to wss://\n  if (baseUrl.startsWith('http://')) {\n    return `ws://${baseUrl.slice(7)}`;\n  }\n  if (baseUrl.startsWith('https://')) {\n    return `wss://${baseUrl.slice(8)}`;\n  }\n\n  // If relative URL, resolve using window.location\n  if (baseUrl.startsWith('/')) {\n    const g = globalThis as unknown as { location?: { protocol?: string; host?: string } };\n    if (g?.location) {\n      const protocol = g.location.protocol === 'https:' ? 'wss:' : 'ws:';\n      return `${protocol}//${g.location.host}${baseUrl}`;\n    }\n    return `ws://localhost${baseUrl}`;\n  }\n\n  // Assume ws:// by default\n  return `ws://${baseUrl}`;\n}\n\n/**\n * Create a typed WebSocket client for a contract\n *\n * @param contract - The WebSocket contract definition\n * @param config - Client configuration with baseUrl\n * @returns Client object with methods for each endpoint\n *\n * @example\n * ```typescript\n * const wsContract = defineWebSocketContract({\n *   chat: {\n *     path: '/ws/chat/:roomId',\n *     params: z.object({ roomId: z.string() }),\n *     clientMessages: {\n *       sendMessage: { payload: z.object({ text: z.string() }) },\n *     },\n *     serverMessages: {\n *       message: { payload: z.object({ userId: z.string(), text: z.string() }) },\n *     },\n *   },\n * });\n *\n * const wsClient = createWebSocketClient(wsContract, { baseUrl: 'ws://localhost:3000' });\n *\n * // Create connection instance\n * const chat = wsClient.chat({ params: { roomId: 'room1' } });\n *\n * // Connect and get disconnect function\n * const disconnect = chat.connect();\n *\n * // Subscribe to state changes\n * chat.onStateChange((connected) => {\n *   console.log('Connected:', connected);\n * });\n *\n * // Subscribe to specific message types\n * chat.on('message', (payload) => {\n *   console.log(`${payload.userId}: ${payload.text}`);\n * });\n *\n * // Send messages\n * chat.send('sendMessage', { text: 'Hello!' });\n *\n * // Disconnect when done\n * disconnect();\n * ```\n */\nexport function createWebSocketClient<T extends WebSocketContract>(\n  contract: T,\n  config: WebSocketClientConfig,\n): WebSocketClient<T> {\n  const resolvedBaseUrl = resolveWebSocketUrl(config.baseUrl);\n\n  const client: Record<string, unknown> = {};\n\n  for (const [name, endpoint] of Object.entries(contract)) {\n    client[name] = (options: WebSocketConnectionOptions<WebSocketContractDefinition> = {}) => {\n      // Build URL\n      let path = endpoint.path;\n      if (options.params) {\n        path = interpolatePath(path, options.params as Record<string, string | number>);\n      }\n\n      const url = buildUrl(\n        resolvedBaseUrl,\n        path,\n        options.query as Record<string, string | number | boolean | string[]> | undefined,\n      );\n\n      return createTypedWebSocket(endpoint, url);\n    };\n  }\n\n  return client as WebSocketClient<T>;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "15DE3AD0993419A564756E2164756E21",
+  "names": []
+}

package/dist/mjs/index.mjs

@@ -60,6 +60,207 @@ function validateResponse(endpoint, status, data) {
     }
   }
 }
+function extractFilename(contentDisposition) {
+  if (!contentDisposition)
+    return null;
+  const filenameStarMatch = contentDisposition.match(/filename\*=(?:UTF-8'')?([^;\s]+)/i);
+  if (filenameStarMatch && filenameStarMatch[1]) {
+    return decodeURIComponent(filenameStarMatch[1]);
+  }
+  const filenameMatch = contentDisposition.match(/filename=["']?([^"';\s]+)["']?/i);
+  if (filenameMatch && filenameMatch[1]) {
+    return filenameMatch[1];
+  }
+  return null;
+}
+function validateDownloadRequest(endpoint, options) {
+  if (endpoint.params && options.params) {
+    const result = endpoint.params.safeParse(options.params);
+    if (!result.success) {
+      throw new ClientValidationError("params", result.error.issues);
+    }
+  }
+  if (endpoint.query && options.query) {
+    const result = endpoint.query.safeParse(options.query);
+    if (!result.success) {
+      throw new ClientValidationError("query", result.error.issues);
+    }
+  }
+  if (endpoint.headers && options.headers) {
+    const result = endpoint.headers.safeParse(options.headers);
+    if (!result.success) {
+      throw new ClientValidationError("headers", result.error.issues);
+    }
+  }
+}
+function validateDownloadErrorResponse(endpoint, status, data) {
+  if (endpoint.errorResponses) {
+    const responseSchema = endpoint.errorResponses[status];
+    if (responseSchema) {
+      const result = responseSchema.safeParse(data);
+      if (!result.success) {
+        throw new ClientValidationError(`response[${status}]`, result.error.issues);
+      }
+    }
+  }
+}
+async function makeDownloadRequest(config, endpoint, options = {}) {
+  if (config.validateRequest !== false) {
+    validateDownloadRequest(endpoint, options);
+  }
+  let path = endpoint.path;
+  if (options.params) {
+    path = interpolatePath(path, options.params);
+  }
+  const url = buildUrl(config.baseUrl, path, options.query);
+  const headers = new Headers(config.headers);
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      headers.set(key, String(value));
+    }
+  }
+  const init = {
+    method: "GET",
+    headers
+  };
+  if (options.abortSignal) {
+    init.signal = options.abortSignal;
+  }
+  const response = await fetch(url, init);
+  if (response.status === 200) {
+    const contentLength = response.headers.get("content-length");
+    const total = contentLength ? parseInt(contentLength, 10) : 0;
+    let blob;
+    if (options.onDownloadProgress && response.body) {
+      const reader = response.body.getReader();
+      const chunks = [];
+      let loaded = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+        loaded += value.length;
+        options.onDownloadProgress({
+          loaded,
+          total,
+          progress: total > 0 ? loaded / total : NaN
+        });
+      }
+      blob = new Blob(chunks);
+    } else {
+      blob = await response.blob();
+    }
+    const contentDisposition = response.headers.get("content-disposition");
+    const filename = extractFilename(contentDisposition) || "download";
+    const contentType2 = response.headers.get("content-type") || "application/octet-stream";
+    const file = new File([blob], filename, { type: contentType2 });
+    return {
+      status: 200,
+      data: file
+    };
+  }
+  let data;
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    data = await response.json();
+  } else {
+    data = await response.text();
+  }
+  if (endpoint.errorResponses && !(response.status in endpoint.errorResponses)) {
+    throw new HTTPError(response.status, response.statusText, data);
+  }
+  if (config.validateResponse !== false) {
+    validateDownloadErrorResponse(endpoint, response.status, data);
+  }
+  return {
+    status: response.status,
+    data
+  };
+}
+function makeRequestWithXHR(config, endpoint, options, url) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest;
+    xhr.open(endpoint.method, url);
+    if (config.headers) {
+      for (const [key, value] of Object.entries(config.headers)) {
+        xhr.setRequestHeader(key, value);
+      }
+    }
+    if (options.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        xhr.setRequestHeader(key, String(value));
+      }
+    }
+    if (options.onUploadProgress) {
+      xhr.upload.onprogress = (e) => {
+        if (e.lengthComputable && options.onUploadProgress) {
+          options.onUploadProgress({
+            loaded: e.loaded,
+            total: e.total,
+            progress: e.loaded / e.total
+          });
+        }
+      };
+    }
+    if (options.abortSignal) {
+      if (options.abortSignal.aborted) {
+        xhr.abort();
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      options.abortSignal.addEventListener("abort", () => {
+        xhr.abort();
+      });
+    }
+    xhr.onload = () => {
+      let data;
+      const responseContentType = xhr.getResponseHeader("content-type") || "";
+      if (xhr.status === 204) {
+        data = {};
+      } else if (responseContentType.includes("application/json")) {
+        try {
+          data = JSON.parse(xhr.responseText);
+        } catch {
+          data = xhr.responseText || {};
+        }
+      } else if (responseContentType.includes("text/")) {
+        data = xhr.responseText;
+      } else {
+        data = xhr.responseText || {};
+      }
+      if (xhr.status >= 400 && !(xhr.status in endpoint.responses)) {
+        reject(new HTTPError(xhr.status, xhr.statusText, data));
+        return;
+      }
+      if (config.validateResponse !== false) {
+        try {
+          validateResponse(endpoint, xhr.status, data);
+        } catch (err) {
+          reject(err);
+          return;
+        }
+      }
+      resolve({
+        status: xhr.status,
+        data
+      });
+    };
+    xhr.onerror = () => reject(new Error("Network error"));
+    xhr.onabort = () => reject(new DOMException("Aborted", "AbortError"));
+    const contentType = endpoint.contentType ?? "application/json";
+    if (options.body !== undefined) {
+      if (contentType === "multipart/form-data") {
+        xhr.send(objectToFormData(options.body));
+      } else {
+        xhr.setRequestHeader("content-type", "application/json");
+        xhr.send(JSON.stringify(options.body));
+      }
+    } else {
+      xhr.send();
+    }
+  });
+}
 async function makeRequest(config, endpoint, options) {
   if (config.validateRequest !== false) {
     validateRequest(endpoint, options);
@@ -69,6 +270,9 @@ async function makeRequest(config, endpoint, options) {
     path = interpolatePath(path, options.params);
   }
   const url = buildUrl(config.baseUrl, path, options.query);
+  if (options.onUploadProgress && options.body !== undefined) {
+    return makeRequestWithXHR(config, endpoint, options, url);
+  }
   const headers = new Headers(config.headers);
   if (options.headers) {
     for (const [key, value] of Object.entries(options.headers)) {
@@ -121,6 +325,189 @@ async function makeRequest(config, endpoint, options) {
     data
   };
 }
+function createStreamingResult(response, controller) {
+  const listeners = {
+    chunk: new Set,
+    close: new Set,
+    error: new Set
+  };
+  (async () => {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim())
+            continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.__final__) {
+              listeners.close.forEach((h) => h(parsed.data));
+            } else {
+              listeners.chunk.forEach((h) => h(parsed));
+            }
+          } catch (parseErr) {
+            listeners.error.forEach((h) => h(parseErr));
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          const parsed = JSON.parse(buffer);
+          if (parsed.__final__) {
+            listeners.close.forEach((h) => h(parsed.data));
+          } else {
+            listeners.chunk.forEach((h) => h(parsed));
+          }
+        } catch {}
+      }
+      listeners.close.forEach((h) => h());
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        listeners.error.forEach((h) => h(err));
+      }
+    }
+  })();
+  return {
+    on(event, handler) {
+      listeners[event].add(handler);
+      return () => listeners[event].delete(handler);
+    },
+    abort() {
+      controller.abort();
+    },
+    get aborted() {
+      return controller.signal.aborted;
+    }
+  };
+}
+function validateStreamingRequest(endpoint, options) {
+  if (endpoint.params && options.params) {
+    const result = endpoint.params.safeParse(options.params);
+    if (!result.success) {
+      throw new ClientValidationError("params", result.error.issues);
+    }
+  }
+  if (endpoint.query && options.query) {
+    const result = endpoint.query.safeParse(options.query);
+    if (!result.success) {
+      throw new ClientValidationError("query", result.error.issues);
+    }
+  }
+  if (endpoint.headers && options.headers) {
+    const result = endpoint.headers.safeParse(options.headers);
+    if (!result.success) {
+      throw new ClientValidationError("headers", result.error.issues);
+    }
+  }
+  if (endpoint.body && options.body) {
+    const result = endpoint.body.safeParse(options.body);
+    if (!result.success) {
+      throw new ClientValidationError("body", result.error.issues);
+    }
+  }
+}
+async function makeStreamingRequest(config, endpoint, options) {
+  if (config.validateRequest !== false) {
+    validateStreamingRequest(endpoint, options);
+  }
+  let path = endpoint.path;
+  if (options.params) {
+    path = interpolatePath(path, options.params);
+  }
+  const url = buildUrl(config.baseUrl, path, options.query);
+  const headers = new Headers(config.headers);
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      headers.set(key, String(value));
+    }
+  }
+  const controller = new AbortController;
+  if (options.abortSignal) {
+    if (options.abortSignal.aborted) {
+      controller.abort();
+    } else {
+      options.abortSignal.addEventListener("abort", () => controller.abort());
+    }
+  }
+  const init = {
+    method: endpoint.method,
+    headers,
+    signal: controller.signal
+  };
+  if (options.body !== undefined) {
+    const contentType = endpoint.contentType ?? "application/json";
+    if (contentType === "multipart/form-data") {
+      init.body = objectToFormData(options.body);
+    } else {
+      headers.set("content-type", "application/json");
+      init.body = JSON.stringify(options.body);
+    }
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const contentType = response.headers.get("content-type") || "";
+    let data;
+    if (contentType.includes("application/json")) {
+      data = await response.json();
+    } else {
+      data = await response.text();
+    }
+    throw new HTTPError(response.status, response.statusText, data);
+  }
+  return createStreamingResult(response, controller);
+}
+function createSSEConnection(config, endpoint, options = {}) {
+  let path = endpoint.path;
+  if (options.params) {
+    path = interpolatePath(path, options.params);
+  }
+  const url = buildUrl(config.baseUrl, path, options.query);
+  const eventSource = new EventSource(url);
+  const listeners = {
+    error: new Set
+  };
+  const eventNames = Object.keys(endpoint.events);
+  for (const eventName of eventNames) {
+    listeners[eventName] = new Set;
+    eventSource.addEventListener(eventName, (e) => {
+      const messageEvent = e;
+      try {
+        const data = JSON.parse(messageEvent.data);
+        listeners[eventName].forEach((h) => h(data, messageEvent.lastEventId || undefined));
+      } catch (err) {
+        listeners.error.forEach((h) => h(new Error(`Failed to parse SSE data: ${err.message}`)));
+      }
+    });
+  }
+  eventSource.onerror = () => {
+    listeners.error.forEach((h) => h(new Error("SSE connection error")));
+  };
+  return {
+    on(event, handler) {
+      if (!listeners[event]) {
+        listeners[event] = new Set;
+      }
+      listeners[event].add(handler);
+      return () => listeners[event].delete(handler);
+    },
+    close() {
+      eventSource.close();
+    },
+    get state() {
+      const states = ["connecting", "open", "closed"];
+      return states[eventSource.readyState];
+    }
+  };
+}
 function resolveBaseUrl(baseUrl) {
   if (baseUrl.startsWith("http://") || baseUrl.startsWith("https://")) {
     return baseUrl;
@@ -139,9 +526,25 @@ function createClient(contract, config) {
   };
   const client = {};
   for (const [name, endpoint] of Object.entries(contract)) {
-    client[name] = (options = {}) => {
-      return makeRequest(resolvedConfig, endpoint, options);
-    };
+    if (endpoint.type === "standard") {
+      client[name] = (options = {}) => {
+        return makeRequest(resolvedConfig, endpoint, options);
+      };
+    } else if (endpoint.type === "streaming") {
+      client[name] = (options = {}) => {
+        return makeStreamingRequest(resolvedConfig, endpoint, options);
+      };
+    } else if (endpoint.type === "sse") {
+      client[name] = (options = {}) => {
+        return createSSEConnection(resolvedConfig, endpoint, options);
+      };
+    } else if (endpoint.type === "download") {
+      client[name] = (options = {}) => {
+        return makeDownloadRequest(resolvedConfig, endpoint, options);
+      };
+    } else {
+      throw new Error(`Endpoint "${name}" has unknown type "${endpoint.type}".`);
+    }
   }
   return client;
 }
@@ -161,4 +564,4 @@ export {
   ClientValidationError
 };
 
-//# debugId=B663AC78F4A6E33F64756E2164756E21
+//# debugId=50D6CA4EBD15A65664756E2164756E21