claritykit-svelte/dist/components/bms/APIDiscoverer/types.d.ts

A comprehensive Svelte component library focused on accessibility, ADHD-optimized design, developer experience, and full SSR compatibility

import type { HTMLAttributes } from 'svelte/elements';
export type DiscoveryMethod = 'url' | 'domain' | 'search' | 'auto';
export type DiscoveryStatus = 'pending' | 'discovering' | 'completed' | 'failed';
export type APIComplexity = 'simple' | 'moderate' | 'complex';
export interface DiscoveryRequest {
    id: string;
    method: DiscoveryMethod;
    input: string;
    serviceName: string;
    customHeaders?: Record<string, string>;
    followRedirects?: boolean;
    validateSchema?: boolean;
    timeout?: number;
    status: DiscoveryStatus;
    startedAt: Date;
    completedAt?: Date;
    error?: string;
    retryCount?: number;
}
export interface DiscoveryResult {
    requestId: string;
    specifications: APISpecification[];
    discoveryMetadata: {
        methodUsed: DiscoveryMethod;
        urlsTested?: string[];
        searchQuery?: string;
        totalAttempts: number;
        executionTime: number;
    };
    fastmcpAnalysis?: FastMCPAnalysis;
    qualityAssessment?: {
        overallScore: number;
        completeness: number;
        documentation: number;
        standardCompliance: number;
        issues: string[];
        recommendations: string[];
    };
}
export interface APISpecification {
    id: string;
    serviceName: string;
    title: string;
    version: string;
    description?: string;
    baseUrl: string;
    specUrl: string;
    openApiVersion: string;
    discoveredAt: Date;
    discoveryMethod?: DiscoveryMethod;
    endpoints: APIEndpoint[];
    schemas: Record<string, SchemaDefinition>;
    authMethods: AuthenticationMethod[];
    category?: string;
    tags?: string[];
    complexity: APIComplexity;
    quality?: {
        score: number;
        issues: QualityIssue[];
        suggestions: string[];
    };
    capabilities?: {
        crud: boolean;
        realtime: boolean;
        webhooks: boolean;
        pagination: boolean;
        filtering: boolean;
        rateLimit: boolean;
        caching: boolean;
    };
    technicalDetails?: {
        dataFormats: string[];
        compressionSupport: boolean;
        httpMethods: string[];
        statusCodes: number[];
        contentTypes: string[];
    };
}
export interface APIEndpoint {
    path: string;
    method: string;
    operationId: string;
    summary?: string;
    description?: string;
    tags?: string[];
    parameters: EndpointParameter[];
    requestBody?: {
        required: boolean;
        contentType: string;
        schema: SchemaDefinition;
        examples?: Record<string, any>;
    };
    responses: Record<string, {
        description: string;
        schema?: SchemaDefinition;
        examples?: Record<string, any>;
        headers?: Record<string, ParameterDefinition>;
    }>;
    security?: Array<Record<string, string[]>>;
    deprecated?: boolean;
    externalDocs?: {
        description: string;
        url: string;
    };
}
export interface EndpointParameter {
    name: string;
    in: 'path' | 'query' | 'header' | 'cookie';
    type: string;
    required: boolean;
    description?: string;
    schema?: SchemaDefinition;
    examples?: Record<string, any>;
    minimum?: number;
    maximum?: number;
    pattern?: string;
    enum?: any[];
    default?: any;
}
export interface SchemaDefinition {
    type: string;
    format?: string;
    description?: string;
    properties?: Record<string, SchemaDefinition>;
    required?: string[];
    items?: SchemaDefinition;
    additionalProperties?: boolean | SchemaDefinition;
    enum?: any[];
    example?: any;
    minimum?: number;
    maximum?: number;
    exclusiveMinimum?: boolean;
    exclusiveMaximum?: boolean;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    minItems?: number;
    maxItems?: number;
    uniqueItems?: boolean;
}
export interface ParameterDefinition {
    type: string;
    description?: string;
    required?: boolean;
    schema?: SchemaDefinition;
}
export interface AuthenticationMethod {
    type: 'apiKey' | 'oauth2' | 'bearer' | 'basic' | 'mutual' | 'openIdConnect';
    name: string;
    location?: 'header' | 'query' | 'cookie';
    description?: string;
    flows?: {
        implicit?: OAuth2Flow;
        password?: OAuth2Flow;
        clientCredentials?: OAuth2Flow;
        authorizationCode?: OAuth2Flow;
    };
    openIdConnectUrl?: string;
    scheme?: string;
    bearerFormat?: string;
}
export interface OAuth2Flow {
    authorizationUrl?: string;
    tokenUrl?: string;
    refreshUrl?: string;
    scopes: Record<string, string>;
}
export interface QualityIssue {
    type: 'missing_description' | 'invalid_schema' | 'broken_reference' | 'inconsistent_naming' | 'security_issue';
    severity: 'low' | 'medium' | 'high' | 'critical';
    location: string;
    message: string;
    suggestion?: string;
}
export interface FastMCPAnalysis {
    complexity: APIComplexity;
    generationStrategy: 'direct' | 'templated' | 'custom';
    estimatedGenerationTime: number;
    recommendedTemplate: string;
    capabilities: {
        crud: boolean;
        authentication: boolean;
        pagination: boolean;
        filtering: boolean;
        realtime: boolean;
        webhooks: boolean;
        fileUpload: boolean;
        bulkOperations: boolean;
    };
    requirements: {
        dependencies: string[];
        environment: string[];
        configuration: string[];
    };
    codeGenerationHints?: {
        clientPattern: 'singleton' | 'factory' | 'builder';
        errorHandling: 'basic' | 'comprehensive';
        retryStrategy: 'none' | 'exponential' | 'linear';
        caching: 'none' | 'memory' | 'persistent';
        logging: 'minimal' | 'detailed';
    };
    integrationAssessment?: {
        bmsSuitability: number;
        oracleIntegration: boolean;
        scribeIntegration: boolean;
        architectIntegration: boolean;
        recommendedUseCases: string[];
        potentialChallenges: string[];
    };
}
export interface APIDiscovererProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * History of discovery requests
     */
    discoveryHistory?: DiscoveryRequest[];
    /**
     * Known API specifications
     */
    knownAPIs?: APISpecification[];
    /**
     * Available discovery methods
     */
    discoveryMethods?: DiscoveryMethod[];
    /**
     * Show specification viewer
     * @default true
     */
    showSpecViewer?: boolean;
    /**
     * Show discovery logs
     * @default true
     */
    showDiscoveryLogs?: boolean;
    /**
     * Enable automatic discovery suggestions
     * @default true
     */
    enableAutoDiscovery?: boolean;
    /**
     * FastMCP configuration
     */
    fastmcpConfig?: {
        timeout: number;
        retries: number;
        followRedirects: boolean;
        validateSchema: boolean;
        cacheResults?: boolean;
        cacheTTL?: number;
    };
    /**
     * Callback when discovery starts
     */
    onDiscoveryStart?: (request: DiscoveryRequest) => void;
    /**
     * Callback when discovery completes
     */
    onDiscoveryComplete?: (request: DiscoveryRequest, result: DiscoveryResult) => void;
    /**
     * Callback when specification is found
     */
    onSpecificationFound?: (specifications: APISpecification[]) => void;
    /**
     * Callback when discovery fails
     */
    onDiscoveryError?: (request: DiscoveryRequest, error: Error) => void;
    /**
     * Callback when specification is selected for integration
     */
    onSpecificationSelect?: (specification: APISpecification) => void;
}
export interface DiscoveryEngine {
    /**
     * Discover API specification by URL
     */
    discoverByUrl: (url: string, options?: DiscoveryOptions) => Promise<DiscoveryResult>;
    /**
     * Discover API specifications by domain scanning
     */
    discoverByDomain: (domain: string, options?: DiscoveryOptions) => Promise<DiscoveryResult>;
    /**
     * Discover API specifications by search
     */
    discoverBySearch: (query: string, options?: DiscoveryOptions) => Promise<DiscoveryResult>;
    /**
     * Auto-discovery with intelligent method selection
     */
    discoverAuto: (input: string, options?: DiscoveryOptions) => Promise<DiscoveryResult>;
    /**
     * Validate and analyze discovered specification
     */
    analyzeSpecification: (spec: APISpecification) => Promise<FastMCPAnalysis>;
    /**
     * Get discovery suggestions for a service
     */
    getSuggestions: (serviceName: string) => Promise<DiscoverySuggestion[]>;
}
export interface DiscoveryOptions {
    timeout?: number;
    retries?: number;
    followRedirects?: boolean;
    validateSchema?: boolean;
    customHeaders?: Record<string, string>;
    userAgent?: string;
    includePaths?: string[];
    excludePaths?: string[];
}
export interface DiscoverySuggestion {
    type: 'common_path' | 'known_service' | 'similar_domain' | 'search_result';
    url: string;
    confidence: number;
    description: string;
    source: string;
}
export interface FastMCPIntegration {
    /**
     * Introspect OpenAPI specification using FastMCP
     */
    introspectAPI: (url: string, options?: IntrospectionOptions) => Promise<FastMCPIntrospectionResult>;
    /**
     * Validate OpenAPI specification
     */
    validateSpecification: (spec: any) => Promise<ValidationResult>;
    /**
     * Generate MCP server code from specification
     */
    generateMCPServer: (spec: APISpecification, config: MCPGenerationConfig) => Promise<string>;
    /**
     * Analyze API for BMS integration suitability
     */
    analyzeBMSSuitability: (spec: APISpecification) => Promise<BMSSuitabilityAnalysis>;
}
export interface IntrospectionOptions {
    timeout?: number;
    validateSchema?: boolean;
    includeExamples?: boolean;
    resolveReferences?: boolean;
    customHeaders?: Record<string, string>;
}
export interface FastMCPIntrospectionResult {
    specification: APISpecification;
    analysis: FastMCPAnalysis;
    metadata: {
        processingTime: number;
        schemaVersion: string;
        toolsGenerated: number;
        complexityScore: number;
    };
    warnings: string[];
    errors: string[];
}
export interface ValidationResult {
    valid: boolean;
    errors: Array<{
        path: string;
        message: string;
        severity: 'error' | 'warning' | 'info';
    }>;
    warnings: string[];
    score: number;
}
export interface MCPGenerationConfig {
    templateType: 'universal' | 'rest' | 'graphql' | 'webhook';
    includeTests: boolean;
    includeDocumentation: boolean;
    errorHandling: 'basic' | 'comprehensive';
    authenticationMethods: string[];
    outputFormat: 'python' | 'typescript' | 'javascript';
}
export interface BMSSuitabilityAnalysis {
    overallScore: number;
    oracleIntegration: {
        suitable: boolean;
        score: number;
        capabilities: string[];
        limitations: string[];
    };
    scribeIntegration: {
        suitable: boolean;
        score: number;
        dataTypes: string[];
        accessPatterns: string[];
    };
    architectIntegration: {
        suitable: boolean;
        score: number;
        workflowCapabilities: string[];
        orchestrationPotential: string[];
    };
    recommendations: Array<{
        type: 'enhancement' | 'limitation' | 'optimization';
        description: string;
        priority: 'low' | 'medium' | 'high';
        effort: 'minimal' | 'moderate' | 'significant';
    }>;
}
export interface APIRegistry {
    /**
     * Register discovered API specification
     */
    registerAPI: (spec: APISpecification) => Promise<void>;
    /**
     * Search registered APIs
     */
    searchAPIs: (query: string, filters?: APISearchFilters) => Promise<APISpecification[]>;
    /**
     * Get API by service name
     */
    getAPI: (serviceName: string) => Promise<APISpecification | null>;
    /**
     * Update API specification
     */
    updateAPI: (id: string, updates: Partial<APISpecification>) => Promise<APISpecification>;
    /**
     * Delete API specification
     */
    deleteAPI: (id: string) => Promise<void>;
    /**
     * Get API categories
     */
    getCategories: () => Promise<Array<{
        name: string;
        count: number;
    }>>;
    /**
     * Get API statistics
     */
    getStatistics: () => Promise<APIRegistryStats>;
}
export interface APISearchFilters {
    category?: string;
    complexity?: APIComplexity[];
    authMethods?: string[];
    capabilities?: string[];
    tags?: string[];
    minQualityScore?: number;
    discoveredAfter?: Date;
    discoveredBefore?: Date;
}
export interface APIRegistryStats {
    totalAPIs: number;
    categoriesCount: number;
    averageQualityScore: number;
    authMethodsDistribution: Record<string, number>;
    complexityDistribution: Record<APIComplexity, number>;
    capabilitiesDistribution: Record<string, number>;
    discoveryMethodsDistribution: Record<DiscoveryMethod, number>;
    recentDiscoveries: number;
}
export interface DiscoveryScheduler {
    /**
     * Schedule periodic discovery for a service
     */
    scheduleDiscovery: (serviceName: string, schedule: DiscoverySchedule) => Promise<string>;
    /**
     * Cancel scheduled discovery
     */
    cancelSchedule: (scheduleId: string) => Promise<void>;
    /**
     * Get active schedules
     */
    getSchedules: () => Promise<DiscoverySchedule[]>;
    /**
     * Trigger immediate discovery
     */
    triggerDiscovery: (scheduleId: string) => Promise<DiscoveryResult>;
}
export interface DiscoverySchedule {
    id: string;
    serviceName: string;
    method: DiscoveryMethod;
    input: string;
    frequency: 'hourly' | 'daily' | 'weekly' | 'monthly';
    enabled: boolean;
    lastRun?: Date;
    nextRun: Date;
    options?: DiscoveryOptions;
    notificationSettings?: {
        onSuccess: boolean;
        onFailure: boolean;
        onChanges: boolean;
        recipients: string[];
    };
}
export interface BMSDiscoveryIntegration {
    /**
     * Discover APIs based on Oracle agent requirements
     */
    discoverForOracle: (requirements: string[]) => Promise<APISpecification[]>;
    /**
     * Discover APIs suitable for Scribe data access
     */
    discoverForScribe: (dataTypes: string[]) => Promise<APISpecification[]>;
    /**
     * Discover APIs for Architect workflow orchestration
     */
    discoverForArchitect: (workflowTypes: string[]) => Promise<APISpecification[]>;
    /**
     * Get discovery recommendations based on BMS usage patterns
     */
    getRecommendations: () => Promise<DiscoveryRecommendation[]>;
    /**
     * Validate API compatibility with BMS agents
     */
    validateBMSCompatibility: (spec: APISpecification) => Promise<BMSCompatibilityResult>;
}
export interface DiscoveryRecommendation {
    type: 'service_integration' | 'workflow_enhancement' | 'data_source' | 'automation_opportunity';
    serviceName: string;
    description: string;
    confidence: number;
    suggestedAPIs: string[];
    benefits: string[];
    effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high';
}
export interface BMSCompatibilityResult {
    compatible: boolean;
    compatibilityScore: number;
    agentCompatibility: {
        oracle: boolean;
        scribe: boolean;
        architect: boolean;
        loopDiagnostic: boolean;
    };
    supportedCapabilities: string[];
    missingCapabilities: string[];
    requiredModifications: string[];
    recommendations: Array<{
        type: 'enhancement' | 'workaround' | 'alternative';
        description: string;
        impact: 'low' | 'medium' | 'high';
    }>;
}
//# sourceMappingURL=types.d.ts.map