/**
 * Model Registry TypeScript Definitions
 *
 * Comprehensive type definitions for the LLM Model Registry system
 * following the TDD implementation and bfapi integration.
 */
export interface LlmModel {
    id: string;
    name: string;
    version: string;
    provider: ModelProvider;
    status: ModelStatus;
    description?: string;
    created_at: string;
    updated_at?: string;
    capabilities?: string[];
    parameters?: ModelParameters;
    metrics?: ModelMetrics;
    deployment_config?: DeploymentConfig;
    tags?: Record<string, string>;
}
export type ModelStatus = 'active' | 'inactive' | 'deploying' | 'failed' | 'archived' | 'maintenance';
export type ModelProvider = 'openai' | 'anthropic' | 'meta' | 'mistral' | 'google' | 'local' | 'custom';
export interface ModelParameters {
    max_tokens?: number;
    temperature?: number;
    top_p?: number;
    top_k?: number;
    frequency_penalty?: number;
    presence_penalty?: number;
    stop_sequences?: string[];
    context_window?: number;
}
export interface ModelMetrics {
    accuracy?: number;
    latency?: number;
    throughput?: number;
    error_rate?: number;
    uptime?: number;
    total_requests?: number;
    successful_requests?: number;
    failed_requests?: number;
    average_response_time?: number;
    p95_response_time?: number;
    memory_usage?: number;
    cpu_usage?: number;
    cost_per_request?: number;
}
export interface DeploymentConfig {
    environment: DeploymentEnvironment;
    strategy: DeploymentStrategy;
    replicas?: number;
    auto_scaling?: boolean;
    health_check?: HealthCheckConfig;
    resources?: ResourceConfig;
}
export type DeploymentEnvironment = 'development' | 'staging' | 'production';
export type DeploymentStrategy = 'blue_green' | 'rolling' | 'canary' | 'recreate';
export interface HealthCheckConfig {
    enabled: boolean;
    endpoint?: string;
    interval?: number;
    timeout?: number;
    retries?: number;
    threshold?: number;
}
export interface ResourceConfig {
    cpu_request?: string;
    cpu_limit?: string;
    memory_request?: string;
    memory_limit?: string;
    gpu_count?: number;
    storage?: string;
}
export interface ModelVersion {
    version: string;
    status: ModelStatus;
    created_at: string;
    deployed_at?: string;
    deployment_id?: string;
    rollback_eligible: boolean;
    metrics?: ModelMetrics;
    changelog?: string;
    artifacts?: string[];
}
export interface ModelCreateRequest {
    name: string;
    provider: ModelProvider;
    version: string;
    description?: string;
    capabilities?: string[];
    parameters?: ModelParameters;
    deployment_config?: Partial<DeploymentConfig>;
    tags?: Record<string, string>;
}
export interface ModelUpdateRequest extends Partial<ModelCreateRequest> {
    id: string;
}
export interface ModelDeploymentRequest {
    model_id: string;
    environment: DeploymentEnvironment;
    strategy?: DeploymentStrategy;
    version?: string;
    config?: Partial<DeploymentConfig>;
    auto_rollback?: boolean;
    rollback_threshold?: number;
}
export interface ModelDeploymentResponse {
    deployment_id: string;
    status: DeploymentStatus;
    model_id: string;
    version: string;
    environment: DeploymentEnvironment;
    strategy: DeploymentStrategy;
    started_at: string;
    estimated_completion?: string;
    progress_percentage?: number;
    current_stage?: string;
    tracking_url?: string;
}
export type DeploymentStatus = 'queued' | 'in_progress' | 'deploying' | 'verifying' | 'completed' | 'failed' | 'rolled_back';
export interface ModelRollbackRequest {
    model_id: string;
    target_version: string;
    reason?: string;
    immediate?: boolean;
}
export interface ModelRollbackResponse {
    rollback_id: string;
    status: RollbackStatus;
    model_id: string;
    current_version: string;
    target_version: string;
    started_at: string;
    estimated_completion?: string;
    reason?: string;
}
export type RollbackStatus = 'initiated' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
export interface ModelListResponse {
    models: LlmModel[];
    total: number;
    page?: number;
    per_page?: number;
    has_more?: boolean;
}
export interface ModelResponse {
    model: LlmModel;
}
export interface ModelVersionsResponse {
    versions: ModelVersion[];
    current_version: string;
    model_id: string;
}
export interface ApiError {
    message: string;
    code: string;
    details?: Record<string, any>;
    timestamp: string;
}
export interface ModelRegistryProps {
    className?: string;
    onModelSelect?: (model: LlmModel) => void;
    onModelCreate?: (model: LlmModel) => void;
    onModelUpdate?: (model: LlmModel) => void;
    onModelDelete?: (modelId: string) => void;
    showActions?: boolean;
    searchable?: boolean;
    filterable?: boolean;
    pageSize?: number;
}
export interface ModelCardProps {
    model: LlmModel;
    onEdit?: (model: LlmModel) => void;
    onDeploy?: (model: LlmModel) => void;
    onDelete?: (model: LlmModel) => void;
    onViewVersions?: (model: LlmModel) => void;
    onClick?: (model: LlmModel) => void;
    showActions?: boolean;
    className?: string;
}
export interface ModelFormProps {
    model?: LlmModel;
    onSubmit: (data: ModelCreateRequest | ModelUpdateRequest) => void;
    onCancel: () => void;
    loading?: boolean;
    error?: string;
}
export interface ModelDeploymentFormProps {
    model: LlmModel;
    onSubmit: (data: ModelDeploymentRequest) => void;
    onCancel: () => void;
    loading?: boolean;
    error?: string;
}
export interface ModelVersionsProps {
    modelId: string;
    currentVersion: string;
    onRollback?: (version: string) => void;
    onVersionSelect?: (version: ModelVersion) => void;
    loading?: boolean;
    error?: string;
}
export interface ModelFilters {
    status?: ModelStatus[];
    provider?: ModelProvider[];
    environment?: DeploymentEnvironment[];
    search?: string;
    tags?: string[];
    created_after?: string;
    created_before?: string;
}
export interface ModelSortOptions {
    field: 'name' | 'created_at' | 'updated_at' | 'version' | 'status';
    direction: 'asc' | 'desc';
}
export interface ModelRegistryContextValue {
    models: LlmModel[];
    loading: boolean;
    error: string | null;
    filters: ModelFilters;
    sortOptions: ModelSortOptions;
    selectedModel: LlmModel | null;
    fetchModels: (filters?: ModelFilters) => Promise<void>;
    createModel: (data: ModelCreateRequest) => Promise<LlmModel>;
    updateModel: (data: ModelUpdateRequest) => Promise<LlmModel>;
    deleteModel: (modelId: string) => Promise<void>;
    deployModel: (data: ModelDeploymentRequest) => Promise<ModelDeploymentResponse>;
    rollbackModel: (data: ModelRollbackRequest) => Promise<ModelRollbackResponse>;
    getModelVersions: (modelId: string) => Promise<ModelVersion[]>;
    setFilters: (filters: Partial<ModelFilters>) => void;
    setSortOptions: (options: ModelSortOptions) => void;
    selectModel: (model: LlmModel | null) => void;
    clearError: () => void;
}
export interface UseModelRegistryReturn extends ModelRegistryContextValue {
}
export interface UseModelDeploymentReturn {
    deployment: ModelDeploymentResponse | null;
    loading: boolean;
    error: string | null;
    deploy: (data: ModelDeploymentRequest) => Promise<void>;
    checkStatus: (deploymentId: string) => Promise<ModelDeploymentResponse>;
    cancel: (deploymentId: string) => Promise<void>;
    clearError: () => void;
}
export interface UseModelVersionsReturn {
    versions: ModelVersion[];
    loading: boolean;
    error: string | null;
    fetchVersions: (modelId: string) => Promise<void>;
    rollback: (data: ModelRollbackRequest) => Promise<void>;
    clearError: () => void;
}
export interface ModelValidationRules {
    name: {
        required: boolean;
        minLength: number;
        maxLength: number;
        pattern?: RegExp;
    };
    version: {
        required: boolean;
        pattern: RegExp;
    };
    provider: {
        required: boolean;
        allowedValues: ModelProvider[];
    };
    description: {
        maxLength: number;
    };
}
export declare const MODEL_VALIDATION_RULES: ModelValidationRules;
export declare const MODEL_STATUS_COLORS: Record<ModelStatus, string>;
export declare const DEPLOYMENT_STRATEGY_DESCRIPTIONS: Record<DeploymentStrategy, string>;
//# sourceMappingURL=types.d.ts.map