import { default as OpenAI } from 'openai';
import { Stream } from 'openai/streaming';
import { APIResource } from '../../resource';

export declare class Completions extends APIResource {
    /**
     * Creates a model response for the given chat conversation.
     */
    create(body: ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<OpenAI.ChatCompletion>;
    create(body: ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<OpenAI.ChatCompletionChunk>>;
    protected buildCreateParams(params: ChatCompletionCreateParams): GeminiChat.GenerateContentRequest;
    protected afterResponse(model: string, response: Response): Promise<OpenAI.ChatCompletion>;
    protected afterSSEResponse(model: string, response: Response, controller: AbortController): Stream<OpenAI.ChatCompletionChunk>;
}
export type ChatCompletionCreateParamsNonStreaming = Chat.ChatCompletionCreateParamsNonStreaming;
export type ChatCompletionCreateParamsStreaming = Chat.ChatCompletionCreateParamsStreaming;
export type ChatCompletionCreateParams = Chat.ChatCompletionCreateParams;
export type ChatModel = Chat.ChatModel;
export declare namespace Chat {
    type ChatModel = (string & NonNullable<unknown>) | 'gemini-pro';
    interface ChatCompletionCreateParamsNonStreaming extends OpenAI.ChatCompletionCreateParamsNonStreaming {
        model: ChatModel;
        top_k?: number;
    }
    interface ChatCompletionCreateParamsStreaming extends OpenAI.ChatCompletionCreateParamsStreaming {
        model: ChatModel;
        top_k?: number | null;
    }
    type ChatCompletionCreateParams = ChatCompletionCreateParamsNonStreaming | ChatCompletionCreateParamsStreaming;
}
declare namespace GeminiChat {
    interface GenerationConfig {
        candidateCount?: number;
        stopSequences?: string[];
        maxOutputTokens?: number;
        temperature?: number;
        topP?: number;
        topK?: number;
    }
    interface GenerateContentCandidate {
        index: number;
        content: Content;
        finishReason?: 'FINISH_REASON_UNSPECIFIED' | 'STOP' | 'MAX_TOKENS' | 'SAFETY' | 'RECITATION' | 'OTHER';
        finishMessage?: string;
        citationMetadata?: CitationMetadata;
    }
    interface GenerateContentResponse {
        candidates?: GenerateContentCandidate[];
    }
    interface CitationMetadata {
        citationSources: CitationSource[];
    }
    interface CitationSource {
        startIndex?: number;
        endIndex?: number;
        uri?: string;
        license?: string;
    }
    interface InputContent {
        parts: string | Array<string | Part>;
        role: string;
    }
    interface Content extends InputContent {
        parts: Part[];
    }
    type Part = TextPart | InlineDataPart;
    interface TextPart {
        text: string;
        inlineData?: never;
    }
    interface InlineDataPart {
        text?: never;
        inlineData: GeminiContentBlob;
    }
    interface GeminiContentBlob {
        mimeType: string;
        data: string;
    }
    interface BaseParams {
        generationConfig?: GenerationConfig;
    }
    interface GenerateContentRequest extends BaseParams {
        contents: Content[];
    }
}
export {};