@bagelink/sdk 1.7.101 → 1.8.3

package/dist/index.d.cts

@@ -1,3 +1,159 @@
+/**
+ * StreamController - Elegant event-based SSE stream management
+ * Provides a beautiful, type-safe API for consuming Server-Sent Events
+ */
+interface SSEEvent<T = any> {
+    /** Event type (e.g., "token", "tool_call", "done") */
+    type: string;
+    /** Event data payload */
+    data: T;
+    /** Raw event string */
+    raw?: string;
+}
+type EventHandler<T = any> = (data: T) => void;
+type ErrorHandler = (error: Error) => void;
+type VoidHandler = () => void;
+/**
+ * Type-safe event map for stream events
+ * Maps event names to their data types
+ */
+type StreamEventMap = Record<string, any>;
+/**
+ * StreamController - Chainable event emitter for SSE streams with full type safety
+ * @template TEventMap - Map of event names to their data types
+ *
+ * @example
+ * type ChatEvents = {
+ *   token: { content: string }
+ *   tool_call: { name: string, args: any }
+ *   done: { message: string }
+ * }
+ *
+ * const stream: StreamController<ChatEvents> = ...
+ * stream.on('token', (data) => {
+ *   // `data` is typed as { content: string }
+ *   console.log(data.content)
+ * })
+ */
+declare class StreamController<TEventMap extends StreamEventMap = StreamEventMap> {
+    private streamFn;
+    private handlers;
+    private errorHandlers;
+    private completeHandlers;
+    private abortController;
+    private _closed;
+    private _promise;
+    private _resolvePromise;
+    private _rejectPromise;
+    constructor(streamFn: (onEvent: (event: SSEEvent) => void, onError: (error: Error) => void, onComplete: () => void) => () => void);
+    private start;
+    /**
+     * Register an event handler (fully typed!)
+     * @param event - Event type to listen for
+     * @param handler - Handler function (data type inferred from event)
+     * @returns this (for chaining)
+     */
+    on<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Register a one-time event handler (fully typed!)
+     * @param event - Event type to listen for
+     * @param handler - Handler function (called once then removed, data type inferred from event)
+     * @returns this (for chaining)
+     */
+    once<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Remove an event handler (fully typed!)
+     * @param event - Event type
+     * @param handler - Handler to remove
+     * @returns this (for chaining)
+     */
+    off<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Remove all handlers for an event (or all events if no event specified)
+     */
+    removeAllListeners(event?: keyof TEventMap | 'error' | 'complete'): this;
+    private emit;
+    private emitError;
+    private emitComplete;
+    /**
+     * Close the stream
+     */
+    close(): void;
+    /**
+     * Check if stream is closed
+     */
+    get closed(): boolean;
+    /**
+     * Convert stream to a Promise that resolves when 'done' event fires
+     * @returns Promise that resolves with the 'done' event data
+     */
+    toPromise<T = any>(): Promise<T>;
+    /**
+     * Make the stream async iterable
+     * Usage: for await (const event of stream) { ... }
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<SSEEvent>;
+    /**
+     * Collect all events into an array until stream completes
+     * @returns Promise<SSEEvent[]>
+     */
+    toArray(): Promise<SSEEvent[]>;
+    /**
+     * Pipe stream events through a transform function
+     */
+    map<R>(transform: (event: SSEEvent) => R): StreamController<TEventMap>;
+    /**
+     * Filter events based on a predicate
+     */
+    filter(predicate: (event: SSEEvent) => boolean): StreamController<TEventMap>;
+}
+
+/**
+ * SSE (Server-Sent Events) Client Utilities
+ * Provides utilities for consuming Server-Sent Events streams
+ */
+
+interface SSEStreamOptions {
+    /** Additional headers to send with the request */
+    headers?: Record<string, string>;
+    /** Whether to include credentials (cookies) with the request */
+    withCredentials?: boolean;
+}
+/**
+ * Creates an SSE stream consumer with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStream(url)
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ *
+ * // Close when needed
+ * stream.close()
+ * ```
+ */
+declare function createSSEStream<TEventMap extends StreamEventMap = StreamEventMap>(url: string, options?: SSEStreamOptions): StreamController<TEventMap>;
+/**
+ * Creates an SSE stream consumer for POST requests with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param body - Request body
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStreamPost(url, { message: 'Hello' })
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ * ```
+ */
+declare function createSSEStreamPost<TEventMap extends StreamEventMap = StreamEventMap, TBody = any>(url: string, body: TBody, options?: SSEStreamOptions): StreamController<TEventMap>;
+
 declare function getPath(pathsObject: PathsObject | undefined, path: string): PathItemObject | undefined;
 /**
  * A type guard to check if the given value is a `ReferenceObject`.
@@ -350,6 +506,58 @@ interface SecurityRequirementObject {
     [name: string]: string[];
 }
 
+/**
+ * Detects if an operation is an SSE (Server-Sent Events) stream endpoint
+ *
+ * Primary detection: Checks for text/event-stream content type in responses
+ * Fallback: Only if no content type is specified, check for explicit SSE keywords
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Whether the operation is an SSE stream
+ */
+declare function isSSEStream(operation: OperationObject): boolean;
+/**
+ * Information about an SSE event type including its fields
+ */
+interface SSEEventTypeInfo {
+    /** Event type name */
+    name: string;
+    /** Event description */
+    description?: string;
+    /** Fields in the event data */
+    fields?: Array<{
+        name: string;
+        description?: string;
+        type?: string;
+    }>;
+}
+/**
+ * Extracts SSE event types from operation description and examples
+ *
+ * Supports multiple documentation formats:
+ * 1. Markdown format: "1. **event_name**: Description"
+ * 2. Legacy format: type: "event_name"
+ * 3. SSE examples: event: event_name
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event types or undefined
+ */
+declare function extractSSEEventTypes(operation: OperationObject): string[] | undefined;
+/**
+ * Extracts detailed SSE event information including field definitions
+ *
+ * Parses markdown documentation format:
+ * ```
+ * 1. **event_name**: Event description
+ *    - `field_name`: Field description
+ *    - `another_field`: Another description
+ * ```
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event type information with fields
+ */
+declare function extractSSEEventInfo(operation: OperationObject): SSEEventTypeInfo[] | undefined;
+
 interface OpenAPIResponse {
     types: string;
     code: string;
@@ -460,5 +668,5 @@ declare class Bagel {
     uploadFile<T>(file: File, options?: UploadOptions): Promise<T>;
 }
 
-export { Bagel, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, _default as openAPI };
-export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };
+export { Bagel, StreamController, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI };
+export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SSEEvent, SSEEventTypeInfo, SSEStreamOptions, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, StreamEventMap, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };

package/dist/index.d.mts

@@ -1,3 +1,159 @@
+/**
+ * StreamController - Elegant event-based SSE stream management
+ * Provides a beautiful, type-safe API for consuming Server-Sent Events
+ */
+interface SSEEvent<T = any> {
+    /** Event type (e.g., "token", "tool_call", "done") */
+    type: string;
+    /** Event data payload */
+    data: T;
+    /** Raw event string */
+    raw?: string;
+}
+type EventHandler<T = any> = (data: T) => void;
+type ErrorHandler = (error: Error) => void;
+type VoidHandler = () => void;
+/**
+ * Type-safe event map for stream events
+ * Maps event names to their data types
+ */
+type StreamEventMap = Record<string, any>;
+/**
+ * StreamController - Chainable event emitter for SSE streams with full type safety
+ * @template TEventMap - Map of event names to their data types
+ *
+ * @example
+ * type ChatEvents = {
+ *   token: { content: string }
+ *   tool_call: { name: string, args: any }
+ *   done: { message: string }
+ * }
+ *
+ * const stream: StreamController<ChatEvents> = ...
+ * stream.on('token', (data) => {
+ *   // `data` is typed as { content: string }
+ *   console.log(data.content)
+ * })
+ */
+declare class StreamController<TEventMap extends StreamEventMap = StreamEventMap> {
+    private streamFn;
+    private handlers;
+    private errorHandlers;
+    private completeHandlers;
+    private abortController;
+    private _closed;
+    private _promise;
+    private _resolvePromise;
+    private _rejectPromise;
+    constructor(streamFn: (onEvent: (event: SSEEvent) => void, onError: (error: Error) => void, onComplete: () => void) => () => void);
+    private start;
+    /**
+     * Register an event handler (fully typed!)
+     * @param event - Event type to listen for
+     * @param handler - Handler function (data type inferred from event)
+     * @returns this (for chaining)
+     */
+    on<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Register a one-time event handler (fully typed!)
+     * @param event - Event type to listen for
+     * @param handler - Handler function (called once then removed, data type inferred from event)
+     * @returns this (for chaining)
+     */
+    once<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Remove an event handler (fully typed!)
+     * @param event - Event type
+     * @param handler - Handler to remove
+     * @returns this (for chaining)
+     */
+    off<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Remove all handlers for an event (or all events if no event specified)
+     */
+    removeAllListeners(event?: keyof TEventMap | 'error' | 'complete'): this;
+    private emit;
+    private emitError;
+    private emitComplete;
+    /**
+     * Close the stream
+     */
+    close(): void;
+    /**
+     * Check if stream is closed
+     */
+    get closed(): boolean;
+    /**
+     * Convert stream to a Promise that resolves when 'done' event fires
+     * @returns Promise that resolves with the 'done' event data
+     */
+    toPromise<T = any>(): Promise<T>;
+    /**
+     * Make the stream async iterable
+     * Usage: for await (const event of stream) { ... }
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<SSEEvent>;
+    /**
+     * Collect all events into an array until stream completes
+     * @returns Promise<SSEEvent[]>
+     */
+    toArray(): Promise<SSEEvent[]>;
+    /**
+     * Pipe stream events through a transform function
+     */
+    map<R>(transform: (event: SSEEvent) => R): StreamController<TEventMap>;
+    /**
+     * Filter events based on a predicate
+     */
+    filter(predicate: (event: SSEEvent) => boolean): StreamController<TEventMap>;
+}
+
+/**
+ * SSE (Server-Sent Events) Client Utilities
+ * Provides utilities for consuming Server-Sent Events streams
+ */
+
+interface SSEStreamOptions {
+    /** Additional headers to send with the request */
+    headers?: Record<string, string>;
+    /** Whether to include credentials (cookies) with the request */
+    withCredentials?: boolean;
+}
+/**
+ * Creates an SSE stream consumer with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStream(url)
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ *
+ * // Close when needed
+ * stream.close()
+ * ```
+ */
+declare function createSSEStream<TEventMap extends StreamEventMap = StreamEventMap>(url: string, options?: SSEStreamOptions): StreamController<TEventMap>;
+/**
+ * Creates an SSE stream consumer for POST requests with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param body - Request body
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStreamPost(url, { message: 'Hello' })
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ * ```
+ */
+declare function createSSEStreamPost<TEventMap extends StreamEventMap = StreamEventMap, TBody = any>(url: string, body: TBody, options?: SSEStreamOptions): StreamController<TEventMap>;
+
 declare function getPath(pathsObject: PathsObject | undefined, path: string): PathItemObject | undefined;
 /**
  * A type guard to check if the given value is a `ReferenceObject`.
@@ -350,6 +506,58 @@ interface SecurityRequirementObject {
     [name: string]: string[];
 }
 
+/**
+ * Detects if an operation is an SSE (Server-Sent Events) stream endpoint
+ *
+ * Primary detection: Checks for text/event-stream content type in responses
+ * Fallback: Only if no content type is specified, check for explicit SSE keywords
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Whether the operation is an SSE stream
+ */
+declare function isSSEStream(operation: OperationObject): boolean;
+/**
+ * Information about an SSE event type including its fields
+ */
+interface SSEEventTypeInfo {
+    /** Event type name */
+    name: string;
+    /** Event description */
+    description?: string;
+    /** Fields in the event data */
+    fields?: Array<{
+        name: string;
+        description?: string;
+        type?: string;
+    }>;
+}
+/**
+ * Extracts SSE event types from operation description and examples
+ *
+ * Supports multiple documentation formats:
+ * 1. Markdown format: "1. **event_name**: Description"
+ * 2. Legacy format: type: "event_name"
+ * 3. SSE examples: event: event_name
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event types or undefined
+ */
+declare function extractSSEEventTypes(operation: OperationObject): string[] | undefined;
+/**
+ * Extracts detailed SSE event information including field definitions
+ *
+ * Parses markdown documentation format:
+ * ```
+ * 1. **event_name**: Event description
+ *    - `field_name`: Field description
+ *    - `another_field`: Another description
+ * ```
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event type information with fields
+ */
+declare function extractSSEEventInfo(operation: OperationObject): SSEEventTypeInfo[] | undefined;
+
 interface OpenAPIResponse {
     types: string;
     code: string;
@@ -460,5 +668,5 @@ declare class Bagel {
     uploadFile<T>(file: File, options?: UploadOptions): Promise<T>;
 }
 
-export { Bagel, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, _default as openAPI };
-export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };
+export { Bagel, StreamController, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI };
+export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SSEEvent, SSEEventTypeInfo, SSEStreamOptions, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, StreamEventMap, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };

package/dist/index.d.ts

@@ -1,3 +1,159 @@
+/**
+ * StreamController - Elegant event-based SSE stream management
+ * Provides a beautiful, type-safe API for consuming Server-Sent Events
+ */
+interface SSEEvent<T = any> {
+    /** Event type (e.g., "token", "tool_call", "done") */
+    type: string;
+    /** Event data payload */
+    data: T;
+    /** Raw event string */
+    raw?: string;
+}
+type EventHandler<T = any> = (data: T) => void;
+type ErrorHandler = (error: Error) => void;
+type VoidHandler = () => void;
+/**
+ * Type-safe event map for stream events
+ * Maps event names to their data types
+ */
+type StreamEventMap = Record<string, any>;
+/**
+ * StreamController - Chainable event emitter for SSE streams with full type safety
+ * @template TEventMap - Map of event names to their data types
+ *
+ * @example
+ * type ChatEvents = {
+ *   token: { content: string }
+ *   tool_call: { name: string, args: any }
+ *   done: { message: string }
+ * }
+ *
+ * const stream: StreamController<ChatEvents> = ...
+ * stream.on('token', (data) => {
+ *   // `data` is typed as { content: string }
+ *   console.log(data.content)
+ * })
+ */
+declare class StreamController<TEventMap extends StreamEventMap = StreamEventMap> {
+    private streamFn;
+    private handlers;
+    private errorHandlers;
+    private completeHandlers;
+    private abortController;
+    private _closed;
+    private _promise;
+    private _resolvePromise;
+    private _rejectPromise;
+    constructor(streamFn: (onEvent: (event: SSEEvent) => void, onError: (error: Error) => void, onComplete: () => void) => () => void);
+    private start;
+    /**
+     * Register an event handler (fully typed!)
+     * @param event - Event type to listen for
+     * @param handler - Handler function (data type inferred from event)
+     * @returns this (for chaining)
+     */
+    on<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Register a one-time event handler (fully typed!)
+     * @param event - Event type to listen for
+     * @param handler - Handler function (called once then removed, data type inferred from event)
+     * @returns this (for chaining)
+     */
+    once<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Remove an event handler (fully typed!)
+     * @param event - Event type
+     * @param handler - Handler to remove
+     * @returns this (for chaining)
+     */
+    off<K extends keyof TEventMap | 'error' | 'complete'>(event: K, handler: K extends 'error' ? ErrorHandler : K extends 'complete' ? VoidHandler : K extends keyof TEventMap ? (data: TEventMap[K]) => void : EventHandler): this;
+    /**
+     * Remove all handlers for an event (or all events if no event specified)
+     */
+    removeAllListeners(event?: keyof TEventMap | 'error' | 'complete'): this;
+    private emit;
+    private emitError;
+    private emitComplete;
+    /**
+     * Close the stream
+     */
+    close(): void;
+    /**
+     * Check if stream is closed
+     */
+    get closed(): boolean;
+    /**
+     * Convert stream to a Promise that resolves when 'done' event fires
+     * @returns Promise that resolves with the 'done' event data
+     */
+    toPromise<T = any>(): Promise<T>;
+    /**
+     * Make the stream async iterable
+     * Usage: for await (const event of stream) { ... }
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<SSEEvent>;
+    /**
+     * Collect all events into an array until stream completes
+     * @returns Promise<SSEEvent[]>
+     */
+    toArray(): Promise<SSEEvent[]>;
+    /**
+     * Pipe stream events through a transform function
+     */
+    map<R>(transform: (event: SSEEvent) => R): StreamController<TEventMap>;
+    /**
+     * Filter events based on a predicate
+     */
+    filter(predicate: (event: SSEEvent) => boolean): StreamController<TEventMap>;
+}
+
+/**
+ * SSE (Server-Sent Events) Client Utilities
+ * Provides utilities for consuming Server-Sent Events streams
+ */
+
+interface SSEStreamOptions {
+    /** Additional headers to send with the request */
+    headers?: Record<string, string>;
+    /** Whether to include credentials (cookies) with the request */
+    withCredentials?: boolean;
+}
+/**
+ * Creates an SSE stream consumer with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStream(url)
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ *
+ * // Close when needed
+ * stream.close()
+ * ```
+ */
+declare function createSSEStream<TEventMap extends StreamEventMap = StreamEventMap>(url: string, options?: SSEStreamOptions): StreamController<TEventMap>;
+/**
+ * Creates an SSE stream consumer for POST requests with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param body - Request body
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStreamPost(url, { message: 'Hello' })
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ * ```
+ */
+declare function createSSEStreamPost<TEventMap extends StreamEventMap = StreamEventMap, TBody = any>(url: string, body: TBody, options?: SSEStreamOptions): StreamController<TEventMap>;
+
 declare function getPath(pathsObject: PathsObject | undefined, path: string): PathItemObject | undefined;
 /**
  * A type guard to check if the given value is a `ReferenceObject`.
@@ -350,6 +506,58 @@ interface SecurityRequirementObject {
     [name: string]: string[];
 }
 
+/**
+ * Detects if an operation is an SSE (Server-Sent Events) stream endpoint
+ *
+ * Primary detection: Checks for text/event-stream content type in responses
+ * Fallback: Only if no content type is specified, check for explicit SSE keywords
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Whether the operation is an SSE stream
+ */
+declare function isSSEStream(operation: OperationObject): boolean;
+/**
+ * Information about an SSE event type including its fields
+ */
+interface SSEEventTypeInfo {
+    /** Event type name */
+    name: string;
+    /** Event description */
+    description?: string;
+    /** Fields in the event data */
+    fields?: Array<{
+        name: string;
+        description?: string;
+        type?: string;
+    }>;
+}
+/**
+ * Extracts SSE event types from operation description and examples
+ *
+ * Supports multiple documentation formats:
+ * 1. Markdown format: "1. **event_name**: Description"
+ * 2. Legacy format: type: "event_name"
+ * 3. SSE examples: event: event_name
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event types or undefined
+ */
+declare function extractSSEEventTypes(operation: OperationObject): string[] | undefined;
+/**
+ * Extracts detailed SSE event information including field definitions
+ *
+ * Parses markdown documentation format:
+ * ```
+ * 1. **event_name**: Event description
+ *    - `field_name`: Field description
+ *    - `another_field`: Another description
+ * ```
+ *
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event type information with fields
+ */
+declare function extractSSEEventInfo(operation: OperationObject): SSEEventTypeInfo[] | undefined;
+
 interface OpenAPIResponse {
     types: string;
     code: string;
@@ -460,5 +668,5 @@ declare class Bagel {
     uploadFile<T>(file: File, options?: UploadOptions): Promise<T>;
 }
 
-export { Bagel, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, _default as openAPI };
-export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };
+export { Bagel, StreamController, createSSEStream, createSSEStreamPost, dereference, extractSSEEventInfo, extractSSEEventTypes, formatAPIErrorMessage, getPath, isReferenceObject, isSSEStream, isSchemaObject, _default as openAPI };
+export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SSEEvent, SSEEventTypeInfo, SSEStreamOptions, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, StreamEventMap, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };