export declare interface Answer {
    answers: string[];
    completion: string;
    model: string;
    object: "answer";
    search_model: string;
    selected_documents: AnswerSelectedDocument[];
}

export declare interface AnswerParamsBase {
    model: string;
    question: string;
    examples: [string, string][];
    examples_context: string;
    search_model?: string;
    max_rerank?: number;
    temperature?: number;
    logprobs?: number;
    max_tokens?: number;
    stop?: string | string[];
    n?: number;
    logit_bias?: Record<string, number>;
    return_metadata?: boolean;
    return_prompt?: boolean;
    expand?: string[];
}

export declare interface AnswerParamsWithDocuments extends AnswerParamsBase {
    documents: string[];
    file?: never;
}

export declare interface AnswerParamsWithFile extends AnswerParamsBase {
    documents?: never;
    file: string;
}

export declare interface AnswerSelectedDocument {
    document: number;
    text: string;
}

export declare interface Choice {
    text: string;
    index: number;
    logprobs: unknown;
    finish_reason: string;
}

export declare interface Classification {
    completion: string;
    label: string;
    model: string;
    object: "classification";
    search_model: string;
    selected_examples: ClassificationSelectedExample[];
}

export declare interface ClassificationParamsBase {
    model: string;
    query: string;
    examples?: [string, string][];
    file?: string;
    labels?: string[];
    search_model?: string;
    temperature?: number;
    logprobs?: number;
    max_examples?: number;
    logit_bias?: Record<string, number>;
    return_prompt?: boolean;
    return_metadata?: boolean;
    expand?: string[];
}

export declare interface ClassificationParamsWithExamples extends ClassificationParamsBase {
    examples: [string, string][];
    file?: never;
}

export declare interface ClassificationParamsWithFile extends ClassificationParamsBase {
    examples?: never;
    file: string;
}

export declare interface ClassificationSelectedExample {
    document: number;
    label: string;
    text: string;
}

export declare class Client {
    #private;
    constructor(options?: ClientOptions);
    /**
     * https://beta.openai.com/docs/api-reference/engines
     */
    readonly engines: {
        list: () => Promise<EngineList>;
        retrieve: (engineId: string) => Promise<Engine>;
    };
    /**
     * https://beta.openai.com/docs/api-reference/completions
     * TODO: support create completions via GET
     */
    readonly completions: {
        create: (engineId: string, requestBody: CompletionParams) => Promise<Completion>;
    };
    /**
     * https://beta.openai.com/docs/api-reference/searches
     */
    readonly search: {
        create: (engineId: string, requestBody: SearchParamsWithDocuments | SearchParamsWithFile) => Promise<SearchList>;
    };
    /**
     * @beta
     * https://beta.openai.com/docs/api-reference/classifications
     */
    readonly classifications: {
        create: (requestBody: ClassificationParamsWithExamples | ClassificationParamsWithFile) => Promise<Classification>;
    };
    /**
     * @beta
     * https://beta.openai.com/docs/api-reference/answers
     */
    readonly answers: {
        create: (requestBody: AnswerParamsWithDocuments | AnswerParamsWithFile) => Promise<Answer>;
    };
    /**
     * TODO: upload, retrieve, delete
     * https://beta.openai.com/docs/api-reference/files
     */
    readonly files: {
        list: () => Promise<FileList_2>;
    };
    /**
     * @beta
     * TODO
     * https://beta.openai.com/docs/guides/fine-tuning
     */
    private fetch;
}

export declare interface ClientOptions {
    /**
     * API key in an Authorization HTTP header
     * https://beta.openai.com/docs/api-reference/authentication
     */
    apiKey?: string;
    /**
     * Count against the specified organization's subscription quota.
     * https://beta.openai.com/docs/api-reference/requesting-organization
     */
    organization?: string;
}

export declare interface Completion {
    id: string;
    object: "text_completion";
    created: number;
    model: string;
    choices: Choice[];
}

export declare interface CompletionParams {
    prompt?: string | string[];
    max_tokens?: number;
    temperature?: number;
    top_p?: number;
    n?: number;
    stream?: boolean;
    logprobs?: number;
    echo?: boolean;
    stop?: string | string[];
    presence_penalty?: number;
    frequency_penalty?: number;
    bestOf?: number;
    logit_bias?: Record<string, number>;
}

export declare type Endpoint = "engines";

export declare interface Engine {
    id: string;
    object: "engine";
    owner: string;
    ready: boolean;
}

export declare interface EngineList {
    object: "list";
    data: Engine[];
}

declare interface File_2 {
    id: string;
    object: "file";
    bytes: number;
    created_at: number;
    filename: string;
    purpose: "search" | "answers" | "classifications" | "fine-tune";
}
export { File_2 as File }

declare interface FileList_2 {
    data: File_2[];
    object: "list";
}
export { FileList_2 as FileList }

export declare interface Search {
    document: number;
    object: "search_result";
    score: number;
}

export declare interface SearchList {
    data: Search[];
    model: string;
    object: "list";
}

export declare interface SearchParamsBase {
    query: string;
    max_rerank?: number;
    return_metadata?: boolean;
}

export declare interface SearchParamsWithDocuments extends SearchParamsBase {
    documents: string[];
    file?: never;
}

export declare interface SearchParamsWithFile extends SearchParamsBase {
    documents?: never;
    file: string;
}

export { }