import { z } from 'zod';
import { Tool } from '@modelcontextprotocol/sdk/types.js';
/**
 * MCP Server Type Definitions
 *
 * Shared types for the Model Context Protocol server infrastructure,
 * tool registry, and server management.
 */
export interface MCPTool extends Tool {
    category: ToolCategory;
    requiresConnection: boolean;
    requiresVersion?: string;
    handler: ToolHandler;
}
export declare enum ToolCategory {
    CONNECTION = "connection",
    DEVICES = "devices",
    CLIENTS = "clients",
    FIREWALL_LEGACY = "firewall-legacy",
    FIREWALL_ZBF = "firewall-zbf",
    NETWORKS = "networks",
    GROUPS = "groups",
    MONITORING = "monitoring",
    AUTOMATION = "automation"
}
export type ToolHandler = (params: Record<string, any>) => Promise<ToolResult>;
export interface ToolResult {
    success: boolean;
    data?: any;
    error?: {
        code: string;
        message: string;
        details?: any;
    };
    warnings?: string[];
    metadata?: {
        executionTime: number;
        timestamp: Date;
        version?: string;
    };
}
export declare const ServerConfigSchema: z.ZodObject<{
    name: z.ZodDefault<z.ZodString>;
    version: z.ZodDefault<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    author: z.ZodOptional<z.ZodString>;
    capabilities: z.ZodDefault<z.ZodObject<{
        tools: z.ZodDefault<z.ZodBoolean>;
        resources: z.ZodDefault<z.ZodBoolean>;
        prompts: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        tools: boolean;
        resources: boolean;
        prompts: boolean;
    }, {
        tools?: boolean | undefined;
        resources?: boolean | undefined;
        prompts?: boolean | undefined;
    }>>;
    features: z.ZodDefault<z.ZodObject<{
        enableZBFTools: z.ZodDefault<z.ZodBoolean>;
        enableLegacyFirewall: z.ZodDefault<z.ZodBoolean>;
        enableMonitoring: z.ZodDefault<z.ZodBoolean>;
        enableAutomation: z.ZodDefault<z.ZodBoolean>;
        enableCache: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        enableZBFTools: boolean;
        enableLegacyFirewall: boolean;
        enableMonitoring: boolean;
        enableAutomation: boolean;
        enableCache: boolean;
    }, {
        enableZBFTools?: boolean | undefined;
        enableLegacyFirewall?: boolean | undefined;
        enableMonitoring?: boolean | undefined;
        enableAutomation?: boolean | undefined;
        enableCache?: boolean | undefined;
    }>>;
    rateLimit: z.ZodDefault<z.ZodObject<{
        perMinute: z.ZodDefault<z.ZodNumber>;
        concurrent: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        perMinute: number;
        concurrent: number;
    }, {
        perMinute?: number | undefined;
        concurrent?: number | undefined;
    }>>;
    cache: z.ZodDefault<z.ZodObject<{
        ttlSeconds: z.ZodDefault<z.ZodNumber>;
        maxSize: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        ttlSeconds: number;
        maxSize: number;
    }, {
        ttlSeconds?: number | undefined;
        maxSize?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    version: string;
    capabilities: {
        tools: boolean;
        resources: boolean;
        prompts: boolean;
    };
    features: {
        enableZBFTools: boolean;
        enableLegacyFirewall: boolean;
        enableMonitoring: boolean;
        enableAutomation: boolean;
        enableCache: boolean;
    };
    rateLimit: {
        perMinute: number;
        concurrent: number;
    };
    cache: {
        ttlSeconds: number;
        maxSize: number;
    };
    description?: string | undefined;
    author?: string | undefined;
}, {
    name?: string | undefined;
    version?: string | undefined;
    description?: string | undefined;
    author?: string | undefined;
    capabilities?: {
        tools?: boolean | undefined;
        resources?: boolean | undefined;
        prompts?: boolean | undefined;
    } | undefined;
    features?: {
        enableZBFTools?: boolean | undefined;
        enableLegacyFirewall?: boolean | undefined;
        enableMonitoring?: boolean | undefined;
        enableAutomation?: boolean | undefined;
        enableCache?: boolean | undefined;
    } | undefined;
    rateLimit?: {
        perMinute?: number | undefined;
        concurrent?: number | undefined;
    } | undefined;
    cache?: {
        ttlSeconds?: number | undefined;
        maxSize?: number | undefined;
    } | undefined;
}>;
export type ServerConfig = z.infer<typeof ServerConfigSchema>;
export interface ConnectionState {
    isConnected: boolean;
    isAuthenticated: boolean;
    lastConnected?: Date;
    lastError?: string;
    retryCount: number;
    gatewayInfo?: {
        ip: string;
        version: string;
        model: string;
        siteId: string;
    };
}
export interface ConnectionPool {
    primary: ConnectionState;
    backup?: ConnectionState;
    healthCheck: {
        lastCheck: Date;
        isHealthy: boolean;
        latency: number;
    };
}
export interface FeatureCapabilities {
    version: string;
    supportsZBF: boolean;
    supportsLegacyFirewall: boolean;
    supportedEndpoints: string[];
    deprecatedEndpoints: string[];
    hardwareCapabilities: {
        model: string;
        supportsAdvancedFirewall: boolean;
        maxFirewallRules: number;
        maxZones: number;
    };
}
export interface ToolAvailability {
    [toolName: string]: {
        available: boolean;
        reason?: string;
        alternativeTool?: string;
        minimumVersion?: string;
    };
}
export declare enum ErrorCode {
    CONNECTION_FAILED = "CONNECTION_FAILED",
    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
    NETWORK_TIMEOUT = "NETWORK_TIMEOUT",
    SSL_ERROR = "SSL_ERROR",
    API_KEY_INVALID = "API_KEY_INVALID",
    API_RATE_LIMITED = "API_RATE_LIMITED",
    API_ENDPOINT_NOT_FOUND = "API_ENDPOINT_NOT_FOUND",
    API_PERMISSION_DENIED = "API_PERMISSION_DENIED",
    FEATURE_NOT_SUPPORTED = "FEATURE_NOT_SUPPORTED",
    HARDWARE_INCOMPATIBLE = "HARDWARE_INCOMPATIBLE",
    VERSION_INCOMPATIBLE = "VERSION_INCOMPATIBLE",
    VALIDATION_ERROR = "VALIDATION_ERROR",
    PARAMETER_MISSING = "PARAMETER_MISSING",
    PARAMETER_INVALID = "PARAMETER_INVALID",
    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
    RESOURCE_CONFLICT = "RESOURCE_CONFLICT",
    RESOURCE_LIMIT_EXCEEDED = "RESOURCE_LIMIT_EXCEEDED",
    INTERNAL_ERROR = "INTERNAL_ERROR",
    CONFIG_ERROR = "CONFIG_ERROR",
    CACHE_ERROR = "CACHE_ERROR",
    INITIALIZATION_ERROR = "INITIALIZATION_ERROR",
    TOOL_REGISTRATION_ERROR = "TOOL_REGISTRATION_ERROR",
    TOOL_NOT_FOUND = "TOOL_NOT_FOUND",
    TOOL_DISABLED = "TOOL_DISABLED",
    CONNECTION_REQUIRED = "CONNECTION_REQUIRED",
    FEATURE_NOT_AVAILABLE = "FEATURE_NOT_AVAILABLE",
    EXECUTION_ERROR = "EXECUTION_ERROR",
    UNKNOWN_FEATURE = "UNKNOWN_FEATURE",
    CAPABILITY_DETECTION_FAILED = "CAPABILITY_DETECTION_FAILED",
    INVALID_DATA = "INVALID_DATA",
    SYSTEM_INFO_ERROR = "SYSTEM_INFO_ERROR",
    RULE_CREATION_FAILED = "RULE_CREATION_FAILED",
    RULE_UPDATE_FAILED = "RULE_UPDATE_FAILED",
    RULE_DELETION_FAILED = "RULE_DELETION_FAILED",
    RULE_TOGGLE_FAILED = "RULE_TOGGLE_FAILED",
    BLOCK_FAILED = "BLOCK_FAILED",
    UNBLOCK_FAILED = "UNBLOCK_FAILED",
    KICK_FAILED = "KICK_FAILED",
    RESTART_FAILED = "RESTART_FAILED",
    ADOPTION_FAILED = "ADOPTION_FAILED",
    UPGRADE_FAILED = "UPGRADE_FAILED"
}
export interface CacheEntry<T = any> {
    key: string;
    data: T;
    createdAt: Date;
    expiresAt: Date;
    hits: number;
    category: string;
}
export interface CacheStats {
    totalEntries: number;
    hitRate: number;
    missRate: number;
    evictions: number;
    memoryUsage: number;
    categories: Record<string, number>;
}
export declare enum CacheCategory {
    SYSTEM_INFO = "system_info",
    DEVICE_LIST = "device_list",
    CLIENT_LIST = "client_list",
    NETWORK_CONFIG = "network_config",
    FIREWALL_RULES = "firewall_rules",
    ZONE_POLICIES = "zone_policies",
    STATISTICS = "statistics"
}
export interface RateLimitEntry {
    key: string;
    requests: number;
    resetTime: Date;
    category: string;
}
export interface RateLimitConfig {
    perMinute: number;
    concurrent: number;
    burstAllowance: number;
    backoffMultiplier: number;
}
export declare enum LogLevel {
    ERROR = "error",
    WARN = "warn",
    INFO = "info",
    DEBUG = "debug",
    TRACE = "trace"
}
export interface LogEntry {
    timestamp: Date;
    level: LogLevel;
    message: string;
    category: string;
    metadata?: Record<string, any>;
    error?: Error;
    requestId?: string;
    toolName?: string;
    executionTime?: number;
}
export interface ServerMetrics {
    uptime: number;
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    activeConnections: number;
    cacheStats: CacheStats;
    toolUsage: Record<string, number>;
    errorCounts: Record<ErrorCode, number>;
    lastUpdated: Date;
}
export interface ToolRegistryEntry {
    tool: MCPTool;
    registered: Date;
    enabled: boolean;
    usageCount: number;
    lastUsed?: Date;
    averageExecutionTime: number;
    errorCount: number;
    dependencies: string[];
}
export interface ToolRegistry {
    tools: Map<string, ToolRegistryEntry>;
    categories: Map<ToolCategory, string[]>;
    dependencies: Map<string, string[]>;
}
export interface HealthCheckResult {
    name: string;
    status: 'healthy' | 'warning' | 'unhealthy';
    message: string;
    details?: Record<string, any>;
    timestamp: Date;
    responseTime: number;
}
export interface SystemHealth {
    overall: 'healthy' | 'warning' | 'unhealthy';
    checks: HealthCheckResult[];
    uptime: number;
    version: string;
    timestamp: Date;
}
export interface PluginManifest {
    name: string;
    version: string;
    description: string;
    author: string;
    tools: string[];
    dependencies: string[];
    apiVersion: string;
}
export interface PluginContext {
    unifiClient: any;
    logger: any;
    config: ServerConfig;
    cache: any;
}
export interface Plugin {
    manifest: PluginManifest;
    initialize(context: PluginContext): Promise<void>;
    getTools(): MCPTool[];
    shutdown(): Promise<void>;
}
declare const ToolResultSchema: z.ZodObject<{
    success: z.ZodBoolean;
    data: z.ZodOptional<z.ZodAny>;
    error: z.ZodOptional<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
        details: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        code: string;
        message: string;
        details?: any;
    }, {
        code: string;
        message: string;
        details?: any;
    }>>;
    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    metadata: z.ZodOptional<z.ZodObject<{
        executionTime: z.ZodNumber;
        timestamp: z.ZodDate;
        version: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        executionTime: number;
        timestamp: Date;
        version?: string | undefined;
    }, {
        executionTime: number;
        timestamp: Date;
        version?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    error?: {
        code: string;
        message: string;
        details?: any;
    } | undefined;
    data?: any;
    warnings?: string[] | undefined;
    metadata?: {
        executionTime: number;
        timestamp: Date;
        version?: string | undefined;
    } | undefined;
}, {
    success: boolean;
    error?: {
        code: string;
        message: string;
        details?: any;
    } | undefined;
    data?: any;
    warnings?: string[] | undefined;
    metadata?: {
        executionTime: number;
        timestamp: Date;
        version?: string | undefined;
    } | undefined;
}>;
declare const HealthCheckResultSchema: z.ZodObject<{
    name: z.ZodString;
    status: z.ZodEnum<["healthy", "warning", "unhealthy"]>;
    message: z.ZodString;
    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    timestamp: z.ZodDate;
    responseTime: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    message: string;
    status: "warning" | "healthy" | "unhealthy";
    name: string;
    timestamp: Date;
    responseTime: number;
    details?: Record<string, any> | undefined;
}, {
    message: string;
    status: "warning" | "healthy" | "unhealthy";
    name: string;
    timestamp: Date;
    responseTime: number;
    details?: Record<string, any> | undefined;
}>;
export type Awaitable<T> = T | Promise<T>;
export type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
export type RequiredKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
export type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
export { ToolResultSchema, HealthCheckResultSchema };
//# sourceMappingURL=types.d.ts.map