/**
 * Cross-Language Types for Enhanced Multi-Language Code Analysis
 * Extends the existing types to support polyglot projects
 */
import { FunctionMetadata, ComponentMetadata } from '../types.js';
/**
 * Core cross-language entity that can represent functions, classes, interfaces, etc.
 * across multiple programming languages
 */
export interface CrossLanguageEntity {
    id: string;
    name: string;
    language: string;
    file: string;
    type: 'function' | 'class' | 'interface' | 'struct' | 'module' | 'component' | 'service' | 'endpoint';
    startLine?: number;
    endLine?: number;
    lineNumber?: number;
    signature: string;
    parameters: ParameterInfo[];
    returnType?: string;
    visibility?: 'public' | 'private' | 'protected' | 'internal' | 'package';
    calls: CrossReference[];
    calledBy: CrossReference[];
    implements?: string[];
    implementedBy?: string[];
    extends?: string;
    extendedBy?: string[];
    apiEndpoint?: string;
    apiMethod?: string;
    apiContract?: APIContract;
    purpose: string;
    context: string;
    jsDoc?: JSDocInfo;
    searchTokens: string[];
    importPath?: string;
    complexity?: number;
    testCoverage?: number;
    metadata?: Record<string, any>;
    createdAt?: Date;
    updatedAt?: Date;
}
/**
 * Enhanced parameter information for cross-language support
 */
export interface ParameterInfo {
    name: string;
    type?: string;
    description?: string;
    optional?: boolean;
    defaultValue?: string;
    constraints?: string[];
    isVariadic?: boolean;
    language: string;
}
/**
 * Cross-language reference between entities
 */
export interface CrossReference {
    sourceId: string;
    targetId: string;
    type: 'calls' | 'implements' | 'extends' | 'imports' | 'api-call' | 'grpc-call' | 'graphql-query';
    sourceLanguage: string;
    targetLanguage: string;
    confidence: number;
    protocol?: 'http' | 'grpc' | 'graphql' | 'direct' | 'websocket';
    metadata?: {
        endpoint?: string;
        method?: string;
        schema?: any;
        line?: number;
        column?: number;
    };
}
/**
 * API contract definition for service interfaces
 */
export interface APIContract {
    version?: string;
    request?: TypeSchema;
    response?: TypeSchema;
    errors?: ErrorSchema[];
    authentication?: AuthenticationSpec;
    rateLimit?: RateLimitSpec;
    deprecated?: boolean;
    deprecationDate?: Date;
    migration?: string;
}
/**
 * Type schema for API contracts
 */
export interface TypeSchema {
    type: string;
    properties?: Record<string, TypeSchema>;
    items?: TypeSchema;
    required?: string[];
    description?: string;
    example?: any;
    constraints?: {
        minLength?: number;
        maxLength?: number;
        pattern?: string;
        minimum?: number;
        maximum?: number;
    };
}
/**
 * Error schema for API contracts
 */
export interface ErrorSchema {
    code: string | number;
    message: string;
    description?: string;
    schema?: TypeSchema;
    httpStatus?: number;
}
/**
 * Authentication specification
 */
export interface AuthenticationSpec {
    type: 'bearer' | 'basic' | 'apikey' | 'oauth2' | 'custom';
    description?: string;
    scopes?: string[];
    header?: string;
}
/**
 * Rate limiting specification
 */
export interface RateLimitSpec {
    requests: number;
    window: string;
    burst?: number;
}
/**
 * Enhanced JSDoc information
 */
export interface JSDocInfo {
    description?: string;
    examples?: string[];
    tags?: Record<string, string[]>;
    params?: Record<string, string>;
    returns?: string;
    throws?: string[];
    since?: string;
    deprecated?: string;
    see?: string[];
}
/**
 * Language adapter interface for extracting entities
 */
export interface LanguageAdapter {
    language: string;
    extensions: string[];
    extractEntities(filePath: string, content: string): Promise<CrossLanguageEntity[]>;
    parseFile(filePath: string): Promise<{
        entities: CrossLanguageEntity[];
        dependencies: string[];
        exports: string[];
        imports: string[];
    }>;
    detectReferences(entities: CrossLanguageEntity[]): Promise<CrossReference[]>;
    validateAPIContract?(entity: CrossLanguageEntity): Promise<APIContract | null>;
}
/**
 * Enhanced database document types
 */
export interface CrossLanguageEntityDocument extends CrossLanguageEntity {
    $loki?: number;
    meta?: any;
}
export interface CrossReferenceDocument extends CrossReference {
    $loki?: number;
    meta?: any;
    createdAt?: Date;
    updatedAt?: Date;
}
export interface APIContractDocument extends APIContract {
    $loki?: number;
    meta?: any;
    entityId: string;
    createdAt?: Date;
    updatedAt?: Date;
}
/**
 * Migration utilities for existing data
 */
export interface MigrationOptions {
    preserveExisting: boolean;
    enhanceMetadata: boolean;
    buildReferences: boolean;
    validateContracts: boolean;
}
/**
 * Compatibility adapters for existing types
 */
export interface CompatibilityAdapter {
    convertFunction(func: FunctionMetadata): CrossLanguageEntity;
    convertComponent(comp: ComponentMetadata): CrossLanguageEntity;
    toFunctionMetadata(entity: CrossLanguageEntity): FunctionMetadata;
    toComponentMetadata(entity: CrossLanguageEntity): ComponentMetadata;
}
/**
 * Search and indexing types
 */
export interface CrossLanguageSearchOptions {
    languages?: string[];
    types?: string[];
    includeReferences?: boolean;
    includeContracts?: boolean;
    confidenceThreshold?: number;
}
export interface CrossLanguageSearchResult {
    entity: CrossLanguageEntity;
    score: number;
    matches: string[];
    references?: CrossReference[];
    contracts?: APIContract[];
}
/**
 * Analysis and reporting types
 */
export interface CrossLanguageAnalysisResult {
    totalEntities: number;
    entitiesByLanguage: Record<string, number>;
    entitiesByType: Record<string, number>;
    crossReferences: number;
    apiContracts: number;
    orphanedEntities: string[];
    complexities: Record<string, number>;
    coverage: Record<string, number>;
}
export interface DependencyGraph {
    nodes: DependencyNode[];
    edges: DependencyEdge[];
    cycles: DependencyCycle[];
    metrics: DependencyMetrics;
}
export interface DependencyNode {
    id: string;
    name: string;
    language: string;
    type: string;
    file: string;
    weight?: number;
    cluster?: string;
}
export interface DependencyEdge {
    from: string;
    to: string;
    type: string;
    weight?: number;
    protocol?: string;
}
export interface DependencyCycle {
    nodes: string[];
    severity: 'warning' | 'critical';
    suggestion?: string;
}
export interface DependencyMetrics {
    totalNodes: number;
    totalEdges: number;
    cycleCount: number;
    averageDepth: number;
    maxDepth: number;
    stronglyConnectedComponents: number;
}
//# sourceMappingURL=crossLanguage.d.ts.map