/**
 * Core types for BFUI component library
 * Shared interfaces and types used across components
 */
import { ReactNode } from 'react';
import { z } from 'zod';
export interface BaseComponentProps {
    id?: string;
    className?: string;
    'data-testid'?: string;
    children?: ReactNode;
}
export interface ApiResponse<T> {
    data: T;
    status: number;
    message?: string;
    metadata?: Record<string, unknown>;
}
export interface ApiError {
    code: string;
    message: string;
    status: number;
    details?: unknown;
}
export interface LoadingState {
    isLoading: boolean;
    error?: ApiError;
    retry?: () => void;
}
export interface PaginationParams {
    page: number;
    pageSize: number;
    total?: number;
    totalPages?: number;
}
export interface SortParams {
    field: string;
    direction: 'asc' | 'desc';
}
export interface FilterParams {
    field: string;
    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith';
    value: unknown;
}
export interface QueryParams {
    pagination?: PaginationParams;
    sort?: SortParams[];
    filters?: FilterParams[];
    search?: string;
    include?: string[];
    select?: string[];
}
export interface ModelMetadata {
    id: string;
    name: string;
    version: string;
    description: string;
    framework: string;
    status: 'draft' | 'published' | 'archived';
    createdAt: string;
    updatedAt: string;
    metrics: ModelMetrics;
    tags: string[];
}
export interface ModelMetrics {
    accuracy: number;
    latency: number;
    throughput: number;
    resourceUsage: ResourceMetrics;
}
export interface ResourceMetrics {
    cpu: number;
    memory: number;
    gpu?: number;
}
export interface AgentProfile {
    id: string;
    name: string;
    type: AgentType;
    status: AgentStatus;
    capabilities: AgentCapability[];
    configuration: AgentConfig;
    metrics: AgentMetrics;
    createdAt: string;
    updatedAt: string;
}
export type AgentType = 'task' | 'orchestrator' | 'specialist' | 'general';
export type AgentStatus = 'active' | 'inactive' | 'training' | 'error';
export interface AgentCapability {
    name: string;
    description: string;
    enabled: boolean;
    parameters?: Record<string, unknown>;
}
export interface AgentConfig {
    modelId: string;
    temperature: number;
    maxTokens: number;
    stopSequences: string[];
    systemPrompt: string;
    tools: AgentTool[];
}
export interface AgentTool {
    name: string;
    description: string;
    parameters: Record<string, unknown>;
    enabled: boolean;
}
export interface AgentMetrics {
    requestsPerMinute: number;
    averageLatency: number;
    successRate: number;
    errorRate: number;
    resourceUsage: ResourceMetrics;
}
export interface MCPServer {
    id: string;
    name: string;
    status: ServerStatus;
    endpoint: string;
    version: string;
    capabilities: ServerCapability[];
    metrics: ServerMetrics;
    configuration: ServerConfig;
}
export type ServerStatus = 'online' | 'offline' | 'maintenance' | 'error';
export interface ServerCapability {
    name: string;
    enabled: boolean;
    parameters?: Record<string, unknown>;
}
export interface ServerMetrics {
    uptime: number;
    activeConnections: number;
    requestsPerMinute: number;
    averageLatency: number;
    resourceUsage: ResourceMetrics;
}
export interface ServerConfig {
    maxConcurrentRequests: number;
    timeout: number;
    retryPolicy: RetryPolicy;
    security: SecurityConfig;
}
export interface RetryPolicy {
    maxAttempts: number;
    backoff: 'linear' | 'exponential';
    maxDelay: number;
}
export interface SecurityConfig {
    authentication: boolean;
    ssl: boolean;
    allowedOrigins: string[];
    rateLimit: RateLimit;
}
export interface RateLimit {
    requestsPerMinute: number;
    burstSize: number;
}
export interface Workflow {
    id: string;
    name: string;
    description?: string;
    nodes: WorkflowNode[];
    edges: WorkflowEdge[];
    metadata?: Record<string, unknown>;
    version: string;
    createdAt: string;
    updatedAt: string;
}
export interface WorkflowNode {
    id: string;
    type: string;
    position: {
        x: number;
        y: number;
    };
    data: {
        label: string;
        config: Record<string, unknown>;
    };
}
export interface WorkflowEdge {
    id: string;
    source: string;
    target: string;
    type?: string;
    data?: Record<string, unknown>;
}
export interface ValidationResult {
    isValid: boolean;
    errors: ValidationError[];
    warnings: ValidationWarning[];
}
export interface ValidationError {
    code: string;
    message: string;
    path: string[];
    severity: 'error' | 'warning';
}
export interface ValidationWarning {
    code: string;
    message: string;
    path: string[];
}
export interface ComplianceReport {
    id: string;
    timestamp: string;
    status: 'compliant' | 'non-compliant' | 'warning';
    score: number;
    frameworks: Array<{
        name: string;
        status: 'compliant' | 'non-compliant' | 'warning';
        score: number;
        issues: Array<{
            severity: 'critical' | 'high' | 'medium' | 'low';
            description: string;
            recommendation: string;
        }>;
    }>;
    metadata?: Record<string, unknown>;
}
export interface AccessibilityResult {
    id: string;
    timestamp: string;
    status: 'pass' | 'fail' | 'warning';
    issues: Array<{
        type: string;
        level: 'critical' | 'serious' | 'moderate' | 'minor';
        description: string;
        element?: string;
        recommendation: string;
    }>;
    metadata?: Record<string, unknown>;
}
export interface DashboardConfig {
    id: string;
    name: string;
    layout: DashboardLayout;
    widgets: DashboardWidget[];
    refreshInterval: number;
    access: DashboardAccess;
}
export interface DashboardLayout {
    type: 'grid' | 'flex';
    columns: number;
    rows: number;
    widgets: WidgetPosition[];
}
export interface WidgetPosition {
    widgetId: string;
    x: number;
    y: number;
    width: number;
    height: number;
}
export interface DashboardWidget {
    id: string;
    type: WidgetType;
    title: string;
    dataSource: WidgetDataSource;
    configuration: WidgetConfig;
    refreshInterval?: number;
}
export type WidgetType = 'metric' | 'chart' | 'table' | 'status' | 'log' | 'agent' | 'model' | 'workflow';
export interface WidgetDataSource {
    type: 'api' | 'websocket' | 'event';
    endpoint: string;
    parameters?: Record<string, unknown>;
}
export interface WidgetConfig {
    visualization: VisualizationConfig;
    filters?: FilterParams[];
    sorting?: SortParams;
    pagination?: PaginationParams;
}
export interface VisualizationConfig {
    type: 'line' | 'bar' | 'pie' | 'table' | 'metric' | 'status';
    options: Record<string, unknown>;
}
export interface DashboardAccess {
    roles: string[];
    permissions: string[];
    public: boolean;
}
export declare const WorkflowSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodString;
        position: z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            x: number;
            y: number;
        }, {
            x: number;
            y: number;
        }>;
        data: z.ZodObject<{
            label: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, "strip", z.ZodTypeAny, {
            label: string;
            config: Record<string, unknown>;
        }, {
            label: string;
            config: Record<string, unknown>;
        }>;
    }, "strip", z.ZodTypeAny, {
        type: string;
        id: string;
        position: {
            x: number;
            y: number;
        };
        data: {
            label: string;
            config: Record<string, unknown>;
        };
    }, {
        type: string;
        id: string;
        position: {
            x: number;
            y: number;
        };
        data: {
            label: string;
            config: Record<string, unknown>;
        };
    }>, "many">;
    edges: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source: z.ZodString;
        target: z.ZodString;
        type: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        source: string;
        target: string;
        type?: string | undefined;
        data?: Record<string, unknown> | undefined;
    }, {
        id: string;
        source: string;
        target: string;
        type?: string | undefined;
        data?: Record<string, unknown> | undefined;
    }>, "many">;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    version: z.ZodString;
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
    id: string;
    edges: {
        id: string;
        source: string;
        target: string;
        type?: string | undefined;
        data?: Record<string, unknown> | undefined;
    }[];
    version: string;
    createdAt: string;
    updatedAt: string;
    nodes: {
        type: string;
        id: string;
        position: {
            x: number;
            y: number;
        };
        data: {
            label: string;
            config: Record<string, unknown>;
        };
    }[];
    metadata?: Record<string, unknown> | undefined;
    description?: string | undefined;
}, {
    name: string;
    id: string;
    edges: {
        id: string;
        source: string;
        target: string;
        type?: string | undefined;
        data?: Record<string, unknown> | undefined;
    }[];
    version: string;
    createdAt: string;
    updatedAt: string;
    nodes: {
        type: string;
        id: string;
        position: {
            x: number;
            y: number;
        };
        data: {
            label: string;
            config: Record<string, unknown>;
        };
    }[];
    metadata?: Record<string, unknown> | undefined;
    description?: string | undefined;
}>;
export type { Workflow as WorkflowType };
export type { WorkflowNode as WorkflowNodeType };
export type { WorkflowEdge as WorkflowEdgeType };
export type { ValidationResult as ValidationResultType };
export type { ValidationError as ValidationErrorType };
export type { ValidationWarning as ValidationWarningType };
export type { ComplianceReport as ComplianceReportType };
export type { AccessibilityResult as AccessibilityResultType };
export type { ApiResponse as ApiResponseType };
export type { ApiError as ApiErrorType };
export type { PaginationParams as PaginationParamsType };
export type { SortParams as SortParamsType };
export type { FilterParams as FilterParamsType };
export type { QueryParams as QueryParamsType };
//# sourceMappingURL=core.d.ts.map