import OpenAIOrignal, { AzureOpenAI, APIPromise, OpenAI, ClientOptions } from 'openai';
import { PostHog } from 'posthog-node';
import { Stream } from 'openai/streaming';
import { ParsedResponse } from 'openai/resources/responses/responses';
import { ResponseCreateParamsWithTools, ExtractParsedContentFromParams } from 'openai/lib/ResponsesParser';

interface MonitoringEventPropertiesWithDefaults {
    distinctId?: string;
    traceId: string;
    properties?: Record<string, any>;
    privacyMode: boolean;
    groups?: Record<string, any>;
    modelOverride?: string;
    providerOverride?: string;
    costOverride?: CostOverride;
    captureImmediate?: boolean;
}
type MonitoringEventProperties = Partial<MonitoringEventPropertiesWithDefaults>;
type MonitoringParams = {
    [K in keyof MonitoringEventProperties as `posthog${Capitalize<string & K>}`]: MonitoringEventProperties[K];
};
interface CostOverride {
    inputCost: number;
    outputCost: number;
}

type ChatCompletion$1 = OpenAIOrignal.ChatCompletion;
type ChatCompletionChunk$1 = OpenAIOrignal.ChatCompletionChunk;
type ChatCompletionCreateParamsBase$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParams;
type ChatCompletionCreateParamsNonStreaming$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
type ChatCompletionCreateParamsStreaming$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsStreaming;
type ResponsesCreateParamsBase$1 = OpenAIOrignal.Responses.ResponseCreateParams;
type ResponsesCreateParamsNonStreaming$1 = OpenAIOrignal.Responses.ResponseCreateParamsNonStreaming;
type ResponsesCreateParamsStreaming$1 = OpenAIOrignal.Responses.ResponseCreateParamsStreaming;
type CreateEmbeddingResponse$1 = OpenAIOrignal.CreateEmbeddingResponse;
type EmbeddingCreateParams$1 = OpenAIOrignal.EmbeddingCreateParams;
interface MonitoringOpenAIConfig$1 {
    apiKey: string;
    posthog: PostHog;
    baseURL?: string;
}
type RequestOptions$1 = Record<string, any>;
declare class PostHogAzureOpenAI extends AzureOpenAI {
    private readonly phClient;
    chat: WrappedChat$1;
    responses: WrappedResponses$1;
    embeddings: WrappedEmbeddings$1;
    constructor(config: MonitoringOpenAIConfig$1);
}
declare class WrappedChat$1 extends AzureOpenAI.Chat {
    constructor(parentClient: PostHogAzureOpenAI, phClient: PostHog);
    completions: WrappedCompletions$1;
}
declare class WrappedCompletions$1 extends AzureOpenAI.Chat.Completions {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: AzureOpenAI, phClient: PostHog);
    create(body: ChatCompletionCreateParamsNonStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<ChatCompletion$1>;
    create(body: ChatCompletionCreateParamsStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<ChatCompletionChunk$1>>;
    create(body: ChatCompletionCreateParamsBase$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<ChatCompletion$1 | Stream<ChatCompletionChunk$1>>;
}
declare class WrappedResponses$1 extends AzureOpenAI.Responses {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: AzureOpenAI, phClient: PostHog);
    create(body: ResponsesCreateParamsNonStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response>;
    create(body: ResponsesCreateParamsStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
    create(body: ResponsesCreateParamsBase$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response | Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
    parse<Params extends ResponseCreateParamsWithTools, ParsedT = ExtractParsedContentFromParams<Params>>(body: Params & MonitoringParams, options?: RequestOptions$1): APIPromise<ParsedResponse<ParsedT>>;
}
declare class WrappedEmbeddings$1 extends AzureOpenAI.Embeddings {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: AzureOpenAI, phClient: PostHog);
    create(body: EmbeddingCreateParams$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<CreateEmbeddingResponse$1>;
}

declare const Chat: typeof OpenAI.Chat;
declare const Completions: typeof OpenAI.Chat.Completions;
declare const Responses: typeof OpenAI.Responses;
declare const Embeddings: typeof OpenAI.Embeddings;
declare const Audio: typeof OpenAI.Audio;
declare const Transcriptions: typeof OpenAI.Audio.Transcriptions;
type ChatCompletion = OpenAI.ChatCompletion;
type ChatCompletionChunk = OpenAI.ChatCompletionChunk;
type ChatCompletionCreateParamsBase = OpenAI.Chat.Completions.ChatCompletionCreateParams;
type ChatCompletionCreateParamsNonStreaming = OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
type ChatCompletionCreateParamsStreaming = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming;
type ResponsesCreateParamsBase = OpenAI.Responses.ResponseCreateParams;
type ResponsesCreateParamsNonStreaming = OpenAI.Responses.ResponseCreateParamsNonStreaming;
type ResponsesCreateParamsStreaming = OpenAI.Responses.ResponseCreateParamsStreaming;
type CreateEmbeddingResponse = OpenAI.CreateEmbeddingResponse;
type EmbeddingCreateParams = OpenAI.EmbeddingCreateParams;
interface MonitoringOpenAIConfig extends ClientOptions {
    apiKey: string;
    posthog: PostHog;
    baseURL?: string;
}
type RequestOptions = Record<string, unknown>;
declare class PostHogOpenAI extends OpenAI {
    private readonly phClient;
    chat: WrappedChat;
    responses: WrappedResponses;
    embeddings: WrappedEmbeddings;
    audio: WrappedAudio;
    constructor(config: MonitoringOpenAIConfig);
}
declare class WrappedChat extends Chat {
    constructor(parentClient: PostHogOpenAI, phClient: PostHog);
    completions: WrappedCompletions;
}
declare class WrappedCompletions extends Completions {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: OpenAI, phClient: PostHog);
    create(body: ChatCompletionCreateParamsNonStreaming & MonitoringParams, options?: RequestOptions): APIPromise<ChatCompletion>;
    create(body: ChatCompletionCreateParamsStreaming & MonitoringParams, options?: RequestOptions): APIPromise<Stream<ChatCompletionChunk>>;
    create(body: ChatCompletionCreateParamsBase & MonitoringParams, options?: RequestOptions): APIPromise<ChatCompletion | Stream<ChatCompletionChunk>>;
}
declare class WrappedResponses extends Responses {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: OpenAI, phClient: PostHog);
    create(body: ResponsesCreateParamsNonStreaming & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Responses.Response>;
    create(body: ResponsesCreateParamsStreaming & MonitoringParams, options?: RequestOptions): APIPromise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
    create(body: ResponsesCreateParamsBase & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Responses.Response | Stream<OpenAI.Responses.ResponseStreamEvent>>;
    parse<Params extends ResponseCreateParamsWithTools, ParsedT = ExtractParsedContentFromParams<Params>>(body: Params & MonitoringParams, options?: RequestOptions): APIPromise<ParsedResponse<ParsedT>>;
}
declare class WrappedEmbeddings extends Embeddings {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: OpenAI, phClient: PostHog);
    create(body: EmbeddingCreateParams & MonitoringParams, options?: RequestOptions): APIPromise<CreateEmbeddingResponse>;
}
declare class WrappedAudio extends Audio {
    constructor(parentClient: PostHogOpenAI, phClient: PostHog);
    transcriptions: WrappedTranscriptions;
}
declare class WrappedTranscriptions extends Transcriptions {
    private readonly phClient;
    private readonly baseURL;
    constructor(client: OpenAI, phClient: PostHog);
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'json' | undefined> & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Audio.Transcriptions.Transcription>;
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'verbose_json'> & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionVerbose>;
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'srt' | 'vtt' | 'text'> & MonitoringParams, options?: RequestOptions): APIPromise<string>;
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming, options?: RequestOptions): APIPromise<OpenAI.Audio.Transcriptions.Transcription>;
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsStreaming & MonitoringParams, options?: RequestOptions): APIPromise<Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsStreaming & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionCreateResponse | string | Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParams & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionCreateResponse | string | Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
}

export { PostHogAzureOpenAI as AzureOpenAI, PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };