import type { Provider, ModelData } from "@mariozechner/lemmy";
/**
 * Result of model validation with comprehensive type information
 */
export interface ModelValidationResult {
    provider: Provider;
    model: string;
    isKnown: boolean;
    modelData?: ModelData;
    capabilities?: {
        supportsTools: boolean;
        supportsImageInput: boolean;
        contextWindow: number;
        maxOutputTokens: number;
    };
    warnings: string[];
}
/**
 * Configuration for model validation behavior
 */
export interface ModelValidationConfig {
    /** Whether to allow unknown models (default: true) */
    allowUnknownModels?: boolean;
    /** Required capabilities for the model */
    requiredCapabilities?: {
        tools?: boolean;
        images?: boolean;
        minContextWindow?: number;
        minOutputTokens?: number;
    };
    /** Model registries to check against */
    modelRegistries: Record<string, Record<string, ModelData>>;
    /** Model-to-provider mapping */
    modelToProvider: Record<string, Provider>;
}
/**
 * Validate provider with exhaustive TypeScript checking
 */
export declare function validateProvider(provider: string, validProviders: readonly Provider[]): provider is Provider;
/**
 * Get valid providers with exhaustive type checking
 * This ensures all Provider types are accounted for
 */
export declare function getValidProviders(): Provider[];
/**
 * Find model data across all registries
 */
export declare function findModelData(model: string, modelRegistries: Record<string, Record<string, ModelData>>): ModelData | undefined;
/**
 * Get provider for a model from mapping
 */
export declare function getModelProvider(model: string, modelToProvider: Record<string, Provider>): Provider | undefined;
/**
 * Get models that support specific capabilities
 */
export declare function getCapableModels(config: ModelValidationConfig, targetProvider?: Provider): Record<Provider, string[]>;
/**
 * Validate provider and model with comprehensive checking
 */
export declare function validateProviderAndModel(provider: string, model: string, config: ModelValidationConfig): ModelValidationResult | null;
/**
 * Filter providers to exclude specific ones (e.g., for bridging scenarios)
 */
export declare function filterProviders<T extends Provider>(allProviders: Provider[], excludeProviders: T[]): Exclude<Provider, T>[];
/**
 * Get exhaustive provider validation errors
 */
export declare function getProviderValidationError(provider: string): string;
/**
 * Create a type-safe provider validator function
 */
export declare function createProviderValidator(validProviders: readonly Provider[]): (provider: string) => provider is Provider;
/**
 * Exhaustive switch helper for provider-specific logic
 */
export declare function exhaustiveProviderSwitch<T>(provider: Provider, cases: Record<Provider, () => T>): T;
//# sourceMappingURL=provider-validation.d.ts.map