import { MCPFilePath as MCPFilePath$1, MCPConfigParser } from 'agent-files';

interface MCPAppMetadata {
    name: string;
    friendlyName: string;
    paths: MCPFilePath[];
}
interface MCPFilePath extends MCPFilePath$1 {
    parsable?: boolean;
    servers?: MCPServerInfo[];
}
interface PackageVersionInfo {
    packageName: string;
    version?: string;
    isPinned: boolean;
    isLatest: boolean;
}
interface MCPServerInfo {
    name: string;
    command: string;
    args?: string[];
    transport?: 'stdio' | 'sse' | 'http';
    type?: 'sse' | 'http' | 'stdio' | 'streamable-http';
    source?: string;
    env?: Record<string, string>;
    headers?: Record<string, string>;
    status?: 'running' | 'stopped';
    versionInfo?: PackageVersionInfo;
    credentials?: CredentialAnalysisResult;
}
interface MCPFileGroups {
    name: string;
    friendlyName: string;
    paths: MCPFilePath[];
    stats?: {
        serversCount?: number;
    };
}
type MCPFileGroupsResultRecord = Record<string, MCPFileGroups>;
type MCPAppPathsRecord = Record<string, MCPFilePath[]>;
interface CredentialVariable {
    name: string;
    value: string;
    riskLevel: 'low' | 'high';
    source?: 'env' | 'args' | 'headers';
}
interface CredentialAnalysisResult {
    hasCredentials: boolean;
    credentialVars: CredentialVariable[];
    riskLevel: 'none' | 'low' | 'high';
}

interface MCPConfigServiceOptions {
    enableDirectoryBubbling?: boolean;
}
declare class MCPConfigService {
    private pathRegistry;
    private currentOS;
    private debug;
    private directoryBubbleService;
    private versionDetectionService;
    private enableDirectoryBubbling;
    constructor(options?: MCPConfigServiceOptions);
    getConfigFilesPerApp(appName: string): MCPFilePath[];
    getAllConfigFiles(): MCPAppPathsRecord;
    getMCPServersPerApp(appName: string): Promise<MCPServerInfo[]>;
    getAllMCPServers(): Promise<Record<string, MCPServerInfo[]>>;
    getSupportedApps(): MCPAppMetadata[];
    getSupportedOperatingSystems(): string[];
    validateConfigFile(filePath: string): Promise<boolean>;
    protected createParser(filePath: string): MCPConfigParser;
    getMCPFileGroups(): Promise<MCPFileGroupsResultRecord>;
    parseCustomFiles(filePaths: string[]): Promise<MCPFileGroupsResultRecord>;
    registerCustomApp(appName: string, paths: MCPFilePath[]): void;
    private parseConfigFileForServers;
    private convertToMCPServerInfo;
    private getFriendlyName;
}

declare class MCPFiles {
    private mcpConfigService;
    private customFiles?;
    constructor(customFiles?: string[]);
    findFiles(): Promise<MCPFileGroupsResultRecord>;
    getMCPConfigService(): MCPConfigService;
}

export { MCPFiles };