import type { SupportedLocale, ExperienceLevel, DatabaseEngine, DatabaseCategory, ArchitecturePattern, Difficulty, ExecutionMode } from '../common.js';
import type { Estimation, Actuals } from '../estimation.js';
import type { EnvSetupGuide, LintingAnalysis } from '../env.js';
import type { ApiContract, AdvancedTestingDetectionResult } from '../testing.js';
import type { McpServerInfo } from '../mcp.js';
import type { QualityProfile } from '../analysis.js';
import type { OtelDetectionResult } from '../analysis-detection.js';
import type { LlmDetectionResult } from '../llm-security.js';
import type { SupplyChainReport } from '../supply-chain.js';
import type { LocalFirstDetectionResult } from '../local-first.js';
import type { ContextSource } from '../context.js';
import type { HypermediaFramework, TurboSubtype, RenderingMode, BuildToolDetectionResult } from '../stack.js';
import type { EdgeDbDetectionResult } from '../edge-db.js';
import type { AiNativeDetectionResult } from '../ai-native.js';
import type { MobilePlatform, MobileFramework, MobileArchPattern, MobilePackageManager } from './platform-mobile.js';
import type { ProjectCategory } from './platform-specialty.js';
import type { DetectedLibraries } from './library-groups.js';
export type { DetectedLibraries };
export type AgentFramework = 'claude-sdk' | 'crewai' | 'langgraph' | 'vercel-ai' | 'mastra' | 'autogen' | 'semantic-kernel' | 'openai-assistants';
export type MultiAgentTopology = 'hub-and-spoke' | 'swarm' | 'sequential-pipeline';
export type AgentProjectType = 'agent-with-tools' | 'llm-pipeline' | 'rag-system' | 'multi-agent-router';
export interface AgentProjectKnowledge {
    framework: AgentFramework | null;
    llmModel: string | null;
    memoryPersistence: string | null;
    detectedTools: string[];
    projectType: AgentProjectType | null;
    topology: MultiAgentTopology | null;
}
export interface ProjectApp {
    name: string;
    path: string;
    type: 'frontend' | 'backend' | 'mobile' | 'ios' | 'android' | 'desktop' | 'shared' | 'worker' | 'docs';
    language: string;
    framework: string | null;
    database?: DatabaseEngine;
    orm?: string;
    packageManager?: string;
    architecture?: ArchitecturePattern;
    platform?: 'ios' | 'android' | 'web' | 'macos' | 'windows' | 'linux' | 'cross-platform';
    mobilePlatform?: MobilePlatform;
    mobileFramework?: MobileFramework;
    mobileArch?: MobileArchPattern;
    mobilePackageManager?: MobilePackageManager;
    mobileCapabilities?: string[];
    mobileDeployTarget?: string;
}
export interface ProjectKnowledge {
    projectId: string;
    projectPath: string;
    locale: SupportedLocale;
    experienceLevel: ExperienceLevel;
    language: string;
    languageVersion: string | null;
    framework: string | null;
    frameworkVersion: string | null;
    packageManager: string | null;
    buildCommand: string | null;
    testCommand: string | null;
    lintCommand: string | null;
    stack: string[];
    database: DatabaseEngine;
    orm: string | null;
    architecture: ArchitectureDetection;
    apps: ProjectApp[];
    conventions: Record<string, string>;
    layers: string[];
    environments: string[];
    apiContracts: ApiContract[];
    monorepo: boolean;
    externalServices: string[];
    tooling: Record<string, string>;
    specLocation: string;
    envSetup: EnvSetupGuide;
    linting: LintingAnalysis;
    availableMcps: McpServerInfo[];
    docsRegistry: Record<string, {
        base: string;
        search: string;
    }>;
    qualityProfile: QualityProfile;
    lastAnalyzed: string;
    projectCategory?: ProjectCategory;
    agentKnowledge?: AgentProjectKnowledge;
    contextRequested?: boolean;
    contributedSources?: ContextSource[];
    hypermediaFramework?: HypermediaFramework;
    turboSubtype?: TurboSubtype;
    jsComplement?: 'alpine' | 'petite-vue' | 'none';
    rendering?: RenderingMode;
    templateEngine?: string;
    hasBundler?: boolean;
    otelDetection?: OtelDetectionResult;
    supplyChain?: SupplyChainReport;
    llmDetection?: LlmDetectionResult;
    localFirst?: LocalFirstDetectionResult;
    advancedTesting?: AdvancedTestingDetectionResult;
    detectedLibraries?: DetectedLibraries;
    buildTool?: BuildToolDetectionResult;
    edgeDb?: EdgeDbDetectionResult;
    k3sDetected?: boolean;
    nomadDetected?: boolean;
    packageManagerPython?: 'pip' | 'poetry' | 'uv' | 'rye' | 'hatch';
    runtime?: 'node' | 'bun' | 'deno';
    mfeDetection?: MfeDetectionResult;
    aiNativeDetection?: AiNativeDetectionResult;
    databaseCategory?: DatabaseCategory;
    cacheEngine?: 'redis' | 'memcached' | 'valkey' | null;
    searchEngine?: 'elasticsearch' | 'opensearch' | 'meilisearch' | 'algolia' | 'typesense' | null;
    vectorDb?: 'pinecone' | 'weaviate' | 'qdrant' | 'milvus' | 'chromadb' | 'pgvector' | null;
    timeseriesDb?: 'influxdb' | 'timescaledb' | 'questdb' | null;
    graphDb?: 'neo4j' | 'arangodb' | 'neptune' | 'dgraph' | null;
    hasVectorExtension?: boolean;
    cloudDbProvider?: 'aws' | 'gcp' | 'azure' | null;
    userProfile?: 'developer' | 'product-owner' | 'designer' | 'non-technical' | null;
}
export interface ArchitectureDetection {
    primary: ArchitecturePattern;
    secondary: ArchitecturePattern[];
    layers: LayerDefinition[];
    boundaries: ModuleBoundary[];
    communicationPatterns: string[];
    deploymentUnits: string[];
}
export interface LayerDefinition {
    name: string;
    directories: string[];
    responsibility: string;
    dependsOn: string[];
    neverDependsOn: string[];
}
export interface ModuleBoundary {
    name: string;
    directories: string[];
    publicApi: string[];
    internalOnly: string[];
}
export interface Constitution {
    projectId: string;
    principles: ConstitutionPrinciple[];
    createdAt: string;
    updatedAt: string;
    version: number;
}
export interface ConstitutionPrinciple {
    id: string;
    category: 'architecture' | 'security' | 'quality' | 'conventions' | 'tech-stack' | 'workflow';
    principle: string;
    rationale: string;
    enforceLevel: 'strict' | 'recommended';
    autoEnforceable: boolean;
    checkFn?: string;
    source: 'auto-detected' | 'user-defined' | 'claude-md' | 'learned';
    immutable: boolean;
}
export interface ConstitutionViolation {
    principleId: string;
    specId?: string;
    file?: string;
    description: string;
    severity: 'error' | 'warning';
}
export interface ConstitutionMergeResult {
    added: number;
    preserved: number;
    conflicts: string[];
}
export interface GlobalConfig {
    defaultLocale: SupportedLocale;
    defaultExperienceLevel: ExperienceLevel;
    hourlyRate: number;
    pricingOpusPerMToken: number;
    pricingSonnetPerMToken: number;
}
export interface MetricsHistory {
    projectId: string;
    entries: MetricEntry[];
}
export interface MetricEntry {
    specId: string;
    difficulty: Difficulty;
    estimated: Estimation;
    actual: Actuals;
    accuracyScore: number;
}
export interface TokenBudget {
    projectId: string;
    monthlyBudgetUsd: number;
    spentThisMonth: number;
    remainingUsd: number;
    tokensByMode: Record<ExecutionMode, number>;
    savingsVsNaive: number;
}
export interface ProjectCompleteness {
    hasReadme: boolean;
    hasGitignore: boolean;
    hasEnvExample: boolean;
    hasLicense: boolean;
    hasEditorConfig: boolean;
    hasLinting: boolean;
    hasFormatting: boolean;
    hasTesting: boolean;
    hasCiCd: boolean;
    hasErrorTracking: boolean;
    hasTypeChecking: boolean;
    hasSecurityScanning: boolean;
    hasDocumentation: boolean;
    hasContributing: boolean;
    hasChangelogStrategy: boolean;
    hasBackupStrategy: boolean;
    hasAccessibility: boolean;
    hasSeo: boolean;
    hasPerformanceBudget: boolean;
    hasSeedData: boolean;
    completenessScore: number;
}
export type MfeHydrationMode = 'islands' | 'full' | 'none';
export type MfePattern = 'module-federation' | 'single-spa' | 'nx-mfe' | 'none';
export type MfeTool = 'webpack' | 'vite' | 'nx';
export type SignalsLibrary = 'angular' | 'preact' | 'solid' | 'vue';
export interface MfeDetectionResult {
    islandsFramework?: 'astro' | 'fresh';
    hydration?: MfeHydrationMode;
    solidStart?: boolean;
    tanstackStart?: boolean;
    moduleFederation?: {
        pattern: MfePattern;
        tool: MfeTool;
    };
    singleSpa?: boolean;
    nxMfe?: boolean;
    signals?: SignalsLibrary[];
}
//# sourceMappingURL=core.d.ts.map