//#region src/sse/index.d.ts
/**
 * SSE Utilities
 *
 * Shared SSE parsing and stream usage extraction for the SDK.
 * Used by sdk-telemetry, sdk-memory, and other consumers.
 */
/** Raw SSE event data from stream */
interface SSEEventData {
  type: string;
  toolName?: string;
  name?: string;
  callId?: string;
  input?: unknown;
  arguments?: unknown;
  output?: unknown;
  result?: unknown;
  durationMs?: number;
  error?: string;
  message?: string;
  code?: string;
  status?: string;
  tokens?: number;
  model?: string;
  inputTokens?: number;
  outputTokens?: number;
  input_tokens?: number;
  output_tokens?: number;
  cache_read_input_tokens?: number;
  cache_creation_input_tokens?: number;
  usage?: {
    input_tokens?: number;
    output_tokens?: number;
    cache_read_input_tokens?: number;
    cache_creation_input_tokens?: number;
  };
  [key: string]: unknown;
}
/**
 * Parse raw SSE data string into structured event data.
 *
 * Handles the standard SSE format:
 * ```
 * event: eventType
 * data: {"json": "payload"}
 * ```
 */
declare function parseSSEData(rawData: string): SSEEventData | null;
interface SSEParserOptions<T = unknown> {
  /** Log malformed data lines (default: false) */
  logMalformed?: boolean;
  /** Custom data transformer */
  transform?: (raw: string) => T | null;
}
interface ParsedSSEEvent<T = unknown> {
  data: T;
  rawData: string;
  eventId?: string;
  eventType?: string;
}
/**
 * Incremental SSE parser for chunked streams.
 * Feed decoded string chunks via push(); call flush() on stream end.
 */
declare class SSEChunkParser<T = unknown> {
  private buffer;
  private currentEvent;
  private options;
  constructor(options?: SSEParserOptions<T>);
  push(chunk: string): ParsedSSEEvent<T>[];
  flush(): ParsedSSEEvent<T>[];
  private processLines;
  private parseCurrentEvent;
}
/**
 * Parse SSE stream into typed events via async iteration.
 */
declare function parseSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>, options?: SSEParserOptions<T>): AsyncGenerator<ParsedSSEEvent<T>>;
/**
 * Consume SSE stream with callbacks.
 */
declare function consumeSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>, onEvent: (event: ParsedSSEEvent<T>) => void, onError: (error: Error) => void, options?: SSEParserOptions<T>): Promise<void>;
/** Token usage extracted from stream */
interface StreamTokenUsage {
  inputTokens: number;
  outputTokens: number;
  cacheReadTokens?: number;
  cacheWriteTokens?: number;
}
/** Accumulated usage from a stream session */
interface StreamUsageAccumulator {
  /** Total tokens from all events */
  usage: StreamTokenUsage;
  /** Number of LLM response events */
  responseCount: number;
  /** Number of tool calls */
  toolCallCount: number;
  /** Model ID if detected from events */
  modelId?: string;
  /** Start time of accumulation */
  startedAt: Date;
  /** Duration in ms (set on finalize) */
  durationMs?: number;
}
/**
 * StreamUsageExtractor - Accumulates token usage from SSE events.
 *
 * Usage:
 * ```typescript
 * const extractor = createStreamUsageExtractor();
 *
 * // In your stream callback
 * for await (const event of stream) {
 *   extractor.processEvent(event);
 *   // ... handle event
 * }
 *
 * const usage = extractor.finalize();
 * billingService.recordUsage({ usage: usage.usage, ... });
 * ```
 */
declare class StreamUsageExtractor {
  private accumulator;
  private finalized;
  constructor();
  /**
   * Process a raw SSE string (event: xxx\ndata: {...}).
   */
  processRawSSE(raw: string): void;
  /**
   * Process a parsed SSE event object.
   */
  processEvent(event: SSEEventData | Record<string, unknown>): void;
  /**
   * Finalize and return accumulated usage.
   * Sets duration and marks extractor as complete.
   */
  finalize(): StreamUsageAccumulator;
  /**
   * Get current accumulated usage (without finalizing).
   */
  current(): Readonly<StreamUsageAccumulator>;
  /**
   * Reset the extractor for reuse.
   */
  reset(): void;
  private extractTokens;
  private extractUsageSummary;
}
/**
 * Create a new StreamUsageExtractor.
 */
declare function createStreamUsageExtractor(): StreamUsageExtractor;
/**
 * Create a callback wrapper that extracts usage while forwarding events.
 *
 * Usage:
 * ```typescript
 * const { callback, getUsage } = createUsageCallback((event) => {
 *   // your event handler
 * });
 *
 * await orchestrator.executeAgentStream(projectRef, request, callback);
 * const usage = getUsage();
 * ```
 */
declare function createUsageCallback<T extends Record<string, unknown>>(forward?: (event: T) => void): {
  callback: (event: T) => void;
  getUsage: () => StreamUsageAccumulator;
  extractor: StreamUsageExtractor;
};
//#endregion
export { ParsedSSEEvent, SSEChunkParser, SSEEventData, SSEParserOptions, StreamTokenUsage, StreamUsageAccumulator, StreamUsageExtractor, consumeSSEStream, createStreamUsageExtractor, createUsageCallback, parseSSEData, parseSSEStream };
//# sourceMappingURL=index.d.ts.map