import { z } from 'zod';
import type { EndpointFileConfig, FileConfig, RegexLike } from './types/files';
export declare const supportsFiles: {
    openAI: boolean;
    google: boolean;
    assistants: boolean;
    azureAssistants: boolean;
    agents: boolean;
    azureOpenAI: boolean;
    anthropic: boolean;
    custom: boolean;
    bedrock: boolean;
};
export declare const excelFileTypes: string[];
export declare const fullMimeTypesList: string[];
export declare const codeInterpreterMimeTypesList: string[];
export declare const retrievalMimeTypesList: string[];
export declare const imageExtRegex: RegExp;
/** @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html */
export type BedrockDocumentFormat = 'pdf' | 'csv' | 'doc' | 'docx' | 'xls' | 'xlsx' | 'html' | 'txt' | 'md';
/** Maps MIME types to Bedrock Converse API document format values */
export declare const bedrockDocumentFormats: Record<string, BedrockDocumentFormat>;
/**
 * Whether an upload belongs to the conversation rather than to the agent. The value
 * arrives from multipart form data, so it can be the string "false", which is truthy.
 * Shared so the route, the authorization check and processing cannot disagree about it.
 */
export declare const isMessageFileUpload: (value?: boolean | string | null) => boolean;
/**
 * Whether the upload's conversation uses the Responses API, which decides whether Azure
 * can carry a document natively. Multipart form data has no booleans, so it arrives as
 * the string "true".
 */
export declare const isResponsesApiUpload: (value?: boolean | string | null) => boolean;
/**
 * The name a file carries inside the code sandbox.
 *
 * Image uploads are converted to the configured output type while the record keeps the
 * original filename, so the extension has to follow the stored bytes or the sandbox
 * decoder is handed a mismatch. Provisioning and priming both resolve the mount path
 * from here: deriving it twice under different rules leaves a later turn advertising a
 * path that does not exist in the sandbox.
 */
export declare const resolveSandboxFilename: (filename: string, mimeType?: string | null) => string;
/**
 * The Responses setting a turn actually runs on. A saved agent's own record wins, since
 * execution reads its model parameters; a conversation only answers for itself. Upload
 * and delivery must agree here, or a document is stored as raw provider content and then
 * re-resolved to text it has no extraction for.
 */
export declare const resolveUseResponsesApi: (agentValue?: boolean | null, conversationValue?: boolean | null) => boolean | undefined;
export declare const isBedrockDocumentType: (mimeType?: string) => boolean;
/** MIME types Bedrock's Converse document path can send to the model (mirrors `bedrockDocumentFormats`). */
export declare const bedrockDocumentMimeTypes: readonly string[];
/** File extensions accepted by Bedrock document uploads (for input accept attributes) */
export declare const bedrockDocumentExtensions = ".pdf,.csv,.doc,.docx,.xls,.xlsx,.html,.htm,.txt,.md,application/pdf,text/csv,application/csv,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,text/html,text/plain,text/markdown";
/**
 * MIME types the Anthropic Messages API accepts as a plain-text document source
 * (`source.type: 'text'`)
 */
export declare const isAnthropicTextDocumentType: (mimeType?: string) => boolean;
/**
 * MIME types the Anthropic Messages API document path can send to the model
 * (mirrors `isBedrockDocumentType`): PDF via base64, textual types via a
 * plain-text document source. All other types are rejected with a provider 400.
 */
export declare const isAnthropicDocumentType: (mimeType?: string) => boolean;
export declare const excelMimeTypes: RegExp;
export declare const textMimeTypes: RegExp;
export declare const applicationMimeTypes: RegExp;
export declare const imageMimeTypes: RegExp;
export declare const audioMimeTypes: RegExp;
export declare const videoMimeTypes: RegExp;
export declare const defaultOCRMimeTypes: RegExp[];
/** MIME types handled by the built-in document parser (pdf, docx, excel variants, ods/odt) */
export declare const documentParserMimeTypes: RegExp[];
export declare const defaultTextMimeTypes: RegExp[];
export declare const defaultSTTMimeTypes: RegExp[];
export declare const supportedMimeTypes: RegExp[];
export declare const codeInterpreterMimeTypes: RegExp[];
export declare const codeTypeMapping: {
    [key: string]: string;
};
/** Maps image extensions to MIME types for formats browsers may not recognize */
export declare const imageTypeMapping: {
    [key: string]: string;
};
/** Normalizes non-standard MIME types that browsers may report to their canonical forms */
export declare const mimeTypeAliases: Readonly<Record<string, string>>;
/**
 * Infers the MIME type from a file's extension when the browser doesn't recognize it,
 * and normalizes known non-standard MIME type aliases to their canonical forms.
 * @param fileName - The file name including its extension
 * @param currentType - The MIME type reported by the browser (may be empty string)
 * @returns The normalized or inferred MIME type; empty string if unresolvable
 */
export declare function inferMimeType(fileName: string, currentType: string): string;
export declare const retrievalMimeTypes: RegExp[];
export declare const megabyte: number;
/** Helper function to get megabytes value */
export declare const mbToBytes: (mb: number) => number;
export declare const fileConfig: {
    endpoints: {
        assistants: {
            fileLimit: number;
            fileSizeLimit: number;
            totalSizeLimit: number;
            supportedMimeTypes: RegExp[];
            disabled: boolean;
        };
        azureAssistants: {
            fileLimit: number;
            fileSizeLimit: number;
            totalSizeLimit: number;
            supportedMimeTypes: RegExp[];
            disabled: boolean;
        };
        agents: {
            fileLimit: number;
            fileSizeLimit: number;
            totalSizeLimit: number;
            supportedMimeTypes: RegExp[];
            disabled: boolean;
        };
        anthropic: {
            fileLimit: number;
            fileSizeLimit: number;
            totalSizeLimit: number;
            supportedMimeTypes: RegExp[];
            disabled: boolean;
        };
        default: {
            fileLimit: number;
            fileSizeLimit: number;
            totalSizeLimit: number;
            supportedMimeTypes: RegExp[];
            disabled: boolean;
        };
    };
    skills: {
        fileSizeLimit: number;
    };
    serverFileSizeLimit: number;
    avatarSizeLimit: number;
    fileTokenLimit: number;
    fileContextSizeLimit: number;
    fileContextCharLimit: number;
    clientImageResize: {
        enabled: boolean;
        maxWidth: number;
        maxHeight: number;
        quality: number;
        enforced: boolean;
    };
    ocr: {
        supportedMimeTypes: RegExp[];
    };
    text: {
        supportedMimeTypes: RegExp[];
    };
    stt: {
        supportedMimeTypes: RegExp[];
    };
    checkType: (fileType: string, supportedTypes?: RegexLike[]) => boolean;
};
export declare const DefaultLLMDeliveryPath: z.ZodEnum<["provider", "text", "none"]>;
export type TDefaultLLMDeliveryPath = z.infer<typeof DefaultLLMDeliveryPath>;
export declare const defaultLLMDeliveryPathSchema: z.ZodObject<{
    fallback: z.ZodOptional<z.ZodEnum<["provider", "text", "none"]>>;
    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["provider", "text", "none"]>>>;
}, "strip", z.ZodTypeAny, {
    fallback?: "none" | "provider" | "text" | undefined;
    overrides?: Record<string, "none" | "provider" | "text"> | undefined;
}, {
    fallback?: "none" | "provider" | "text" | undefined;
    overrides?: Record<string, "none" | "provider" | "text"> | undefined;
}>;
export type TDefaultLLMDeliveryPathConfig = z.infer<typeof defaultLLMDeliveryPathSchema>;
export declare const endpointFileConfigSchema: z.ZodObject<{
    disabled: z.ZodOptional<z.ZodBoolean>;
    fileLimit: z.ZodOptional<z.ZodNumber>;
    fileSizeLimit: z.ZodOptional<z.ZodNumber>;
    totalSizeLimit: z.ZodOptional<z.ZodNumber>;
    supportedMimeTypes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    defaultLLMDeliveryPath: z.ZodOptional<z.ZodObject<{
        fallback: z.ZodOptional<z.ZodEnum<["provider", "text", "none"]>>;
        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["provider", "text", "none"]>>>;
    }, "strip", z.ZodTypeAny, {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    }, {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    }>>;
    legacyFileUploadUX: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    disabled?: boolean | undefined;
    fileLimit?: number | undefined;
    fileSizeLimit?: number | undefined;
    totalSizeLimit?: number | undefined;
    supportedMimeTypes?: string[] | undefined;
    defaultLLMDeliveryPath?: {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    } | undefined;
    legacyFileUploadUX?: boolean | undefined;
}, {
    disabled?: boolean | undefined;
    fileLimit?: number | undefined;
    fileSizeLimit?: number | undefined;
    totalSizeLimit?: number | undefined;
    supportedMimeTypes?: string[] | undefined;
    defaultLLMDeliveryPath?: {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    } | undefined;
    legacyFileUploadUX?: boolean | undefined;
}>;
export declare const fileConfigSchema: z.ZodObject<{
    endpoints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        disabled: z.ZodOptional<z.ZodBoolean>;
        fileLimit: z.ZodOptional<z.ZodNumber>;
        fileSizeLimit: z.ZodOptional<z.ZodNumber>;
        totalSizeLimit: z.ZodOptional<z.ZodNumber>;
        supportedMimeTypes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
        defaultLLMDeliveryPath: z.ZodOptional<z.ZodObject<{
            fallback: z.ZodOptional<z.ZodEnum<["provider", "text", "none"]>>;
            overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["provider", "text", "none"]>>>;
        }, "strip", z.ZodTypeAny, {
            fallback?: "none" | "provider" | "text" | undefined;
            overrides?: Record<string, "none" | "provider" | "text"> | undefined;
        }, {
            fallback?: "none" | "provider" | "text" | undefined;
            overrides?: Record<string, "none" | "provider" | "text"> | undefined;
        }>>;
        legacyFileUploadUX: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        disabled?: boolean | undefined;
        fileLimit?: number | undefined;
        fileSizeLimit?: number | undefined;
        totalSizeLimit?: number | undefined;
        supportedMimeTypes?: string[] | undefined;
        defaultLLMDeliveryPath?: {
            fallback?: "none" | "provider" | "text" | undefined;
            overrides?: Record<string, "none" | "provider" | "text"> | undefined;
        } | undefined;
        legacyFileUploadUX?: boolean | undefined;
    }, {
        disabled?: boolean | undefined;
        fileLimit?: number | undefined;
        fileSizeLimit?: number | undefined;
        totalSizeLimit?: number | undefined;
        supportedMimeTypes?: string[] | undefined;
        defaultLLMDeliveryPath?: {
            fallback?: "none" | "provider" | "text" | undefined;
            overrides?: Record<string, "none" | "provider" | "text"> | undefined;
        } | undefined;
        legacyFileUploadUX?: boolean | undefined;
    }>>>;
    skills: z.ZodOptional<z.ZodObject<{
        fileSizeLimit: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        fileSizeLimit?: number | undefined;
    }, {
        fileSizeLimit?: number | undefined;
    }>>;
    serverFileSizeLimit: z.ZodOptional<z.ZodNumber>;
    avatarSizeLimit: z.ZodOptional<z.ZodNumber>;
    fileTokenLimit: z.ZodOptional<z.ZodNumber>;
    fileContextSizeLimit: z.ZodOptional<z.ZodNumber>;
    fileContextCharLimit: z.ZodOptional<z.ZodNumber>;
    codeEnvLivenessSafeWindowMs: z.ZodOptional<z.ZodNumber>;
    imageGeneration: z.ZodOptional<z.ZodObject<{
        percentage: z.ZodOptional<z.ZodNumber>;
        px: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        percentage?: number | undefined;
        px?: number | undefined;
    }, {
        percentage?: number | undefined;
        px?: number | undefined;
    }>>;
    clientImageResize: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodOptional<z.ZodBoolean>;
        maxWidth: z.ZodOptional<z.ZodNumber>;
        maxHeight: z.ZodOptional<z.ZodNumber>;
        quality: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        enabled?: boolean | undefined;
        maxWidth?: number | undefined;
        maxHeight?: number | undefined;
        quality?: number | undefined;
    }, {
        enabled?: boolean | undefined;
        maxWidth?: number | undefined;
        maxHeight?: number | undefined;
        quality?: number | undefined;
    }>>;
    ocr: z.ZodOptional<z.ZodObject<{
        supportedMimeTypes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    }, "strip", z.ZodTypeAny, {
        supportedMimeTypes?: string[] | undefined;
    }, {
        supportedMimeTypes?: string[] | undefined;
    }>>;
    text: z.ZodOptional<z.ZodObject<{
        supportedMimeTypes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    }, "strip", z.ZodTypeAny, {
        supportedMimeTypes?: string[] | undefined;
    }, {
        supportedMimeTypes?: string[] | undefined;
    }>>;
    defaultLLMDeliveryPath: z.ZodOptional<z.ZodObject<{
        fallback: z.ZodOptional<z.ZodEnum<["provider", "text", "none"]>>;
        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["provider", "text", "none"]>>>;
    }, "strip", z.ZodTypeAny, {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    }, {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    }>>;
    legacyFileUploadUX: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    ocr?: {
        supportedMimeTypes?: string[] | undefined;
    } | undefined;
    skills?: {
        fileSizeLimit?: number | undefined;
    } | undefined;
    text?: {
        supportedMimeTypes?: string[] | undefined;
    } | undefined;
    fileTokenLimit?: number | undefined;
    defaultLLMDeliveryPath?: {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    } | undefined;
    legacyFileUploadUX?: boolean | undefined;
    endpoints?: Record<string, {
        disabled?: boolean | undefined;
        fileLimit?: number | undefined;
        fileSizeLimit?: number | undefined;
        totalSizeLimit?: number | undefined;
        supportedMimeTypes?: string[] | undefined;
        defaultLLMDeliveryPath?: {
            fallback?: "none" | "provider" | "text" | undefined;
            overrides?: Record<string, "none" | "provider" | "text"> | undefined;
        } | undefined;
        legacyFileUploadUX?: boolean | undefined;
    }> | undefined;
    serverFileSizeLimit?: number | undefined;
    avatarSizeLimit?: number | undefined;
    fileContextSizeLimit?: number | undefined;
    fileContextCharLimit?: number | undefined;
    codeEnvLivenessSafeWindowMs?: number | undefined;
    imageGeneration?: {
        percentage?: number | undefined;
        px?: number | undefined;
    } | undefined;
    clientImageResize?: {
        enabled?: boolean | undefined;
        maxWidth?: number | undefined;
        maxHeight?: number | undefined;
        quality?: number | undefined;
    } | undefined;
}, {
    ocr?: {
        supportedMimeTypes?: string[] | undefined;
    } | undefined;
    skills?: {
        fileSizeLimit?: number | undefined;
    } | undefined;
    text?: {
        supportedMimeTypes?: string[] | undefined;
    } | undefined;
    fileTokenLimit?: number | undefined;
    defaultLLMDeliveryPath?: {
        fallback?: "none" | "provider" | "text" | undefined;
        overrides?: Record<string, "none" | "provider" | "text"> | undefined;
    } | undefined;
    legacyFileUploadUX?: boolean | undefined;
    endpoints?: Record<string, {
        disabled?: boolean | undefined;
        fileLimit?: number | undefined;
        fileSizeLimit?: number | undefined;
        totalSizeLimit?: number | undefined;
        supportedMimeTypes?: string[] | undefined;
        defaultLLMDeliveryPath?: {
            fallback?: "none" | "provider" | "text" | undefined;
            overrides?: Record<string, "none" | "provider" | "text"> | undefined;
        } | undefined;
        legacyFileUploadUX?: boolean | undefined;
    }> | undefined;
    serverFileSizeLimit?: number | undefined;
    avatarSizeLimit?: number | undefined;
    fileContextSizeLimit?: number | undefined;
    fileContextCharLimit?: number | undefined;
    codeEnvLivenessSafeWindowMs?: number | undefined;
    imageGeneration?: {
        percentage?: number | undefined;
        px?: number | undefined;
    } | undefined;
    clientImageResize?: {
        enabled?: boolean | undefined;
        maxWidth?: number | undefined;
        maxHeight?: number | undefined;
        quality?: number | undefined;
    } | undefined;
}>;
export type TFileConfig = z.infer<typeof fileConfigSchema>;
/** Override the MIME-pattern compiler; the server injects a linear-time engine at startup. */
export declare const setFileConfigRegexCompiler: (compile: (pattern: string) => RegexLike) => void;
/** Helper function to safely convert string patterns to matcher objects */
export declare const convertStringsToRegex: (patterns: string[]) => RegexLike[];
/** Detects whether the given MIME type patterns accept all file types (e.g., `.*` or `.+`). */
export declare const isPermissiveMimeConfig: (types?: RegexLike[]) => boolean;
/** The kind of content a provider upload path can actually send to the model. */
export type MimeUploadCategory = 'image' | 'document' | 'audio' | 'video';
/** Describes what an upload path can send, used to scope a configured allowlist to selectable files. */
export interface MimeUploadCapability {
    /** Content categories the path forwards to the model. */
    categories: ReadonlyArray<MimeUploadCategory>;
    /** When `document` is permitted, restrict document types to this set (e.g. Bedrock formats); default: all. */
    documentMimeTypes?: readonly string[];
}
/** Preferred extension for a known document MIME type, including its leading dot. */
export declare function getDocumentFileExtension(mimeType?: string): string | undefined;
/**
 * Resolves the file-input `accept` value for a configured `supportedMimeTypes` allowlist, scoped to
 * what the current upload path (`capability`) can send to the model.
 * - `undefined` for the built-in default or a config that can't be represented safely, so callers
 *   keep their provider-specific filter.
 * - `''` for permissive configs (e.g. `.*`), leaving the picker unrestricted.
 * - a translated `accept` string for a recognized finite allowlist (images, PDFs, Office docs, etc.).
 *
 * The picker `accept` is a UX convenience, not a security boundary: the backend still enforces
 * `supportedMimeTypes` on upload.
 */
export declare const getConfiguredMimeAccept: (types: RegexLike[] | undefined, capability: MimeUploadCapability) => string | undefined;
export declare function getEndpointFileConfig(params: {
    fileConfig?: FileConfig | null;
    endpoint?: string | null;
    endpointType?: string | null;
}): EndpointFileConfig;
export declare function mergeFileConfig(dynamic: z.infer<typeof fileConfigSchema> | undefined): FileConfig;