import { z } from "zod";
export declare const IMAGE_OMITTED_PLACEHOLDER = "[media omitted: invalid or exceeds size limit]";
/**
 * Substituted for image content at request-build time when the target model
 * does not advertise image input. The stored conversation history keeps the
 * real image, so switching to an image-capable model restores it.
 */
export declare const IMAGE_UNSUPPORTED_PLACEHOLDER = "[Image attached \u2014 this model cannot view images]";
export declare const GeneratedMediaModalitySchema: z.ZodEnum<{
    image: "image";
    audio: "audio";
    video: "video";
    file: "file";
}>;
export type GeneratedMediaModality = z.infer<typeof GeneratedMediaModalitySchema>;
export declare const GeneratedMediaSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    type: z.ZodLiteral<"base64">;
    data: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"url">;
    url: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"artifact">;
    artifactId: z.ZodString;
}, z.core.$strip>], "type">;
export type GeneratedMediaSource = z.infer<typeof GeneratedMediaSourceSchema>;
/** Canonical model-generated media, shared by streaming and persistence. */
export declare const GeneratedMediaSchema: z.ZodObject<{
    id: z.ZodString;
    modality: z.ZodEnum<{
        image: "image";
        audio: "audio";
        video: "video";
        file: "file";
    }>;
    mediaType: z.ZodString;
    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"base64">;
        data: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"url">;
        url: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"artifact">;
        artifactId: z.ZodString;
    }, z.core.$strip>], "type">;
    name: z.ZodOptional<z.ZodString>;
    sizeBytes: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
export type GeneratedMedia = z.infer<typeof GeneratedMediaSchema>;
export declare function isGeneratedMedia(value: unknown): value is GeneratedMedia;
export declare function generatedMediaModalityFromMediaType(mediaType: string): GeneratedMediaModality;
export declare const SUPPORTED_IMAGE_MEDIA_TYPES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
export declare const DEFAULT_MAX_IMAGE_BASE64_BYTES: number;
export declare const DEFAULT_MAX_IMAGE_ENCODED_BYTES: number;
export declare const DEFAULT_MAX_IMAGE_DECODED_BYTES: number;
export declare const DEFAULT_MAX_TOTAL_MEDIA_BYTES: number;
export interface ImageMediaLimits {
    maxEncodedBytes?: number;
    maxDecodedBytes?: number;
    supportedMediaTypes?: readonly string[];
}
export interface ImageMediaValidationSuccess {
    ok: true;
    mediaType: string;
    base64: string;
    encodedBytes: number;
    decodedBytes: number;
}
export interface ImageMediaValidationFailure {
    ok: false;
    reason: "unsupported_media_type" | "media_type_mismatch" | "invalid_base64" | "encoded_limit" | "decoded_limit" | "total_limit";
    message: string;
}
export type ImageMediaValidationResult = ImageMediaValidationSuccess | ImageMediaValidationFailure;
export interface MediaBudgetOptions {
    maxImageEncodedBytes?: number;
    maxImageDecodedBytes?: number;
    maxTotalMediaBytes?: number;
}
export interface ResolvedMediaBudget {
    maxImageEncodedBytes: number;
    maxImageDecodedBytes: number;
    maxTotalMediaBytes: number;
}
export interface MediaBudgetState {
    totalEncodedBytes: number;
    keptImages: number;
    omittedImages: number;
    omittedReasons: Partial<Record<ImageMediaValidationFailure["reason"], number>>;
}
export interface Base64MediaValidationSuccess {
    ok: true;
    base64: string;
    encodedBytes: number;
    decodedBytes: number;
}
export interface Base64MediaValidationFailure {
    ok: false;
    reason: "invalid_base64" | "total_limit";
    message: string;
}
export type Base64MediaValidationResult = Base64MediaValidationSuccess | Base64MediaValidationFailure;
export declare function imageBase64EncodedByteLength(base64: string): number;
export declare function imageBase64DecodedByteLength(base64: string): number;
export declare function imageFileMaxDecodedBytesForBase64Limit(maxBase64Bytes?: number): number;
export declare function imageBase64LengthForDecodedBytes(decodedBytes: number): number;
export declare function resolveMediaBudget(options?: MediaBudgetOptions): ResolvedMediaBudget;
export declare function createMediaBudgetState(): MediaBudgetState;
export declare function reserveImageMediaBytes(encodedBytes: number, decodedBytes: number, budget: MediaBudgetOptions, state: MediaBudgetState): ImageMediaValidationFailure | null;
export declare function isBase64Char(charCode: number): boolean;
export declare function isCanonicalBase64(base64: string): boolean;
/** Validate and reserve an arbitrary inline media payload against the turn budget. */
export declare function validateAndReserveBase64Media(data: string, budget: MediaBudgetOptions, state: MediaBudgetState): Base64MediaValidationResult;
export declare function validateImageMedia(mediaType: string | undefined, data: string, limits?: ImageMediaLimits): ImageMediaValidationResult;
export declare function validateAndReserveImageMedia(mediaType: string | undefined, data: string, budget: MediaBudgetOptions, state: MediaBudgetState): ImageMediaValidationResult;