ai-utils.js/model-provider/openai/OpenAIImageGenerationModel.d.ts

Build AI applications, chatbots, and agents with JavaScript and TypeScript.

import { z } from "zod";
import { AbstractModel } from "../../model-function/AbstractModel.js";
import { FunctionOptions } from "../../model-function/FunctionOptions.js";
import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
import { ResponseHandler } from "../../util/api/postToApi.js";
import { OpenAIModelSettings } from "./OpenAIModelSettings.js";
export interface OpenAIImageGenerationCallSettings {
    n?: number;
    size?: "256x256" | "512x512" | "1024x1024";
}
export declare const calculateOpenAIImageGenerationCostInMillicents: ({ settings, }: {
    settings: OpenAIImageGenerationSettings;
}) => number;
export interface OpenAIImageGenerationSettings extends ImageGenerationModelSettings, OpenAIImageGenerationCallSettings, OpenAIModelSettings {
    isUserIdForwardingEnabled?: boolean;
}
/**
 * Create an image generation model that calls the OpenAI AI image creation API.
 *
 * @see https://platform.openai.com/docs/api-reference/images/create
 *
 * @example
 * const { image } = await generateImage(
 *   new OpenAIImageGenerationModel({ size: "512x512" }),
 *   "the wicked witch of the west in the style of early 19th century painting"
 * );
 */
export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImageGenerationSettings> implements ImageGenerationModel<string, OpenAIImageGenerationBase64JsonResponse, OpenAIImageGenerationSettings> {
    constructor(settings: OpenAIImageGenerationSettings);
    readonly provider: "openai";
    readonly modelName: null;
    private get apiKey();
    callAPI<RESULT>(prompt: string, options: {
        responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
    } & FunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
        user?: string;
    }>>): Promise<RESULT>;
    generateImageResponse(prompt: string, options?: FunctionOptions<OpenAIImageGenerationSettings>): Promise<{
        data: {
            b64_json: string;
        }[];
        created: number;
    }>;
    extractBase64Image(response: OpenAIImageGenerationBase64JsonResponse): string;
    withSettings(additionalSettings: Partial<OpenAIImageGenerationSettings>): this;
}
export type OpenAIImageGenerationResponseFormatType<T> = {
    type: "b64_json" | "url";
    handler: ResponseHandler<T>;
};
declare const openAIImageGenerationUrlSchema: z.ZodObject<{
    created: z.ZodNumber;
    data: z.ZodArray<z.ZodObject<{
        url: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        url: string;
    }, {
        url: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    data: {
        url: string;
    }[];
    created: number;
}, {
    data: {
        url: string;
    }[];
    created: number;
}>;
export type OpenAIImageGenerationUrlResponse = z.infer<typeof openAIImageGenerationUrlSchema>;
declare const openAIImageGenerationBase64JsonSchema: z.ZodObject<{
    created: z.ZodNumber;
    data: z.ZodArray<z.ZodObject<{
        b64_json: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        b64_json: string;
    }, {
        b64_json: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    data: {
        b64_json: string;
    }[];
    created: number;
}, {
    data: {
        b64_json: string;
    }[];
    created: number;
}>;
export type OpenAIImageGenerationBase64JsonResponse = z.infer<typeof openAIImageGenerationBase64JsonSchema>;
export declare const OpenAIImageGenerationResponseFormat: {
    url: {
        type: "url";
        handler: ResponseHandler<{
            data: {
                url: string;
            }[];
            created: number;
        }>;
    };
    base64Json: {
        type: "b64_json";
        handler: ResponseHandler<{
            data: {
                b64_json: string;
            }[];
            created: number;
        }>;
    };
};
export {};