import type OpenAI from "openai";
import type { MaximLogger } from "../logger";
import type { Generation, Trace } from "../components";
type ResponseCreateParamsNonStreaming = OpenAI.Responses.ResponseCreateParamsNonStreaming;
type ResponseCreateParamsStreaming = OpenAI.Responses.ResponseCreateParamsStreaming;
type Response = OpenAI.Responses.Response;
/**
 * Async stream wrapper that logs to Maxim when the stream completes.
 * Wraps the OpenAI ResponseStream and captures the final response for logging.
 * Also tracks streaming metrics like time to first token and tokens per second.
 */
declare class ResponseStreamWrapper implements AsyncIterable<OpenAI.Responses.ResponseStreamEvent> {
    private streamManager;
    private generation;
    private trace;
    private isLocalTrace;
    private capturedResponse;
    private consumed;
    private startTime;
    private firstTokenTime;
    private endTime;
    constructor(streamManager: ReturnType<OpenAI["responses"]["stream"]>, generation: Generation | null, trace: Trace | null, isLocalTrace: boolean);
    [Symbol.asyncIterator](): AsyncIterator<OpenAI.Responses.ResponseStreamEvent>;
    /**
     * Check if the event has actual content (text delta).
     */
    private hasContent;
    /**
     * Get output tokens from the final response usage.
     */
    private getOutputTokens;
    private finalizeLoggingAsync;
}
/**
 * Wrapped OpenAI Responses that automatically logs to Maxim.
 *
 * @example
 * ```typescript
 * const client = new MaximOpenAIClient(openai, logger);
 *
 * // Non-streaming
 * const response = await client.responses.create({
 *   model: "gpt-4.1",
 *   input: "Hello, world!"
 * });
 *
 * // Streaming
 * const stream = await client.responses.stream({
 *   model: "gpt-4.1",
 *   input: "Tell me a story"
 * });
 * for await (const event of stream) {
 *   // process events
 * }
 * // Logging happens automatically when stream completes
 * ```
 */
export declare class MaximOpenAIResponses {
    private client;
    private logger;
    constructor(client: OpenAI, logger: MaximLogger);
    /**
     * Start a trace and generation for a Responses API call.
     */
    private startTraceAndGeneration;
    /**
     * Creates a response with automatic Maxim logging.
     *
     * @example
     * ```typescript
     * const response = await client.responses.create({
     *   model: "gpt-4.1",
     *   input: "What is the meaning of life?"
     * });
     * ```
     */
    create(params: ResponseCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response>;
    /**
     * Creates a streaming response with automatic Maxim logging.
     * Logging happens automatically when the stream is consumed.
     *
     * @example
     * ```typescript
     * const stream = client.responses.stream({
     *   model: "gpt-4.1",
     *   input: "Tell me a story"
     * });
     * for await (const event of stream) {
     *   if (event.type === 'response.output_text.delta') {
     *     process.stdout.write(event.delta);
     *   }
     * }
     * // Logging happens automatically when stream completes
     * ```
     */
    stream(params: ResponseCreateParamsStreaming, options?: OpenAI.RequestOptions): ResponseStreamWrapper;
}
export {};