import type { Asset, AssetKind, AssetStatus, Catalog, Dependency, DependencyKind } from "./model.js";
import type { Evidence, Finding } from "./types/diagnostics.js";
import { type InactiveLifecycleStatus } from "./lifecycle.js";
export type CompositionMembership = "required" | "optional";
export type CompositionRelationship = "requires_context" | "optional_context" | "requires_lens" | "optional_lens" | "applies_to";
export interface CompositionAsset {
    id: string;
    kind: AssetKind;
    sourcePath: string;
    status?: AssetStatus;
    statusReason?: string;
    statusChangedAt?: string;
    direct?: boolean;
}
export interface CompositionProvenanceEdge {
    from: string;
    to: string;
    declaredTarget: string;
    kind: DependencyKind;
    relationship: CompositionRelationship;
    declarationIndex?: number;
    membership: CompositionMembership;
    direct: boolean;
    sourcePath: string;
    evidence?: Evidence;
}
export interface CompositionResolutionIssue {
    sourceId: string;
    sourceKind: AssetKind;
    sourcePath: string;
    declaredTarget: string;
    relationship: CompositionRelationship;
    declarationIndex?: number;
    membership: CompositionMembership;
    evidence?: Evidence;
}
export interface CompositionKindMismatch extends CompositionResolutionIssue {
    expectedSourceKind?: AssetKind;
    actualSourceKind: AssetKind;
    expectedTargetKind?: AssetKind;
    actualTargetKind?: AssetKind;
    targetId?: string;
    targetPath?: string;
}
export interface CompositionCycle {
    membership: CompositionMembership;
    assetIds: string[];
    edges: CompositionProvenanceEdge[];
}
export interface CompositionConflictDeclaration {
    from: string;
    to: string;
    sourcePath: string;
    declarationIndex?: number;
    evidence?: Evidence;
}
export interface CompositionConflict {
    left: string;
    right: string;
    membership: CompositionMembership;
    declarations: CompositionConflictDeclaration[];
    leftProvenance: CompositionProvenanceEdge[];
    rightProvenance: CompositionProvenanceEdge[];
}
export interface CompositionFreshnessFinding {
    assetId: string;
    sourcePath: string;
    membership: CompositionMembership;
    isRoot: boolean;
    kind: "expired" | "review_overdue";
    date: string;
    evidence?: Evidence;
}
export interface CompositionLifecycleFinding {
    assetId: string;
    sourcePath: string;
    membership: CompositionMembership;
    isRoot: boolean;
    status: InactiveLifecycleStatus;
    statusReason?: string;
    statusChangedAt?: string;
}
export interface DeclaredCompositionReport {
    root: CompositionAsset;
    requiredAssets: CompositionAsset[];
    optionalAssets: CompositionAsset[];
    provenanceEdges: CompositionProvenanceEdge[];
    unresolvedRequired: CompositionResolutionIssue[];
    unresolvedOptional: CompositionResolutionIssue[];
    kindMismatches: CompositionKindMismatch[];
    requiredCycles: CompositionCycle[];
    optionalCycles: CompositionCycle[];
    requiredConflicts: CompositionConflict[];
    optionalConflictCandidates: CompositionConflict[];
    freshnessFindings: CompositionFreshnessFinding[];
    lifecycleFindings: CompositionLifecycleFinding[];
    requiredComplete: boolean;
    optionalComplete: boolean;
    cycleFree: boolean;
}
/** One resolved explicit composition declaration retained for reverse queries. */
export interface ResolvedCompositionDeclaration {
    source: Asset;
    target: Asset;
    dependency: Dependency;
    relationship: CompositionRelationship;
    declarationForm: string;
    declarationIndex?: number;
    sourcePath: string;
    evidence?: Evidence;
    kindMismatch?: CompositionKindMismatch;
}
/** Reusable repository-wide lookups for declared-composition analysis. */
export interface DeclaredCompositionIndex {
    assetsById: ReadonlyMap<string, Asset>;
    assetsByPath: ReadonlyMap<string, Asset>;
    dependenciesBySource: ReadonlyMap<string, Dependency[]>;
    sortedAssets: Asset[];
    sortedDependencies: Dependency[];
}
export interface DeclaredCompositionScanStats {
    rootsAnalyzed: number;
    peakRetainedRootReports: number;
}
export interface DeclaredCompositionFindingAnalysis {
    findings: Finding[];
    stats: DeclaredCompositionScanStats;
}
/**
 * Resolve the finite closure of explicit required, optional, and applies_to
 * declarations. This is repository analysis; it does not select or load
 * runtime Context.
 */
export declare function resolveDeclaredComposition(catalog: Catalog, rootReference: string, options?: {
    evaluationDate?: string | Date;
}): DeclaredCompositionReport;
/** Build repository-wide lookup tables once for one or many root analyses. */
export declare function prepareDeclaredCompositionIndex(catalog: Catalog): DeclaredCompositionIndex;
/** Resolve one root while reusing a prepared repository-wide index. */
export declare function resolveDeclaredCompositionFromIndex(index: DeclaredCompositionIndex, rootReference: string, options?: {
    evaluationDate?: string | Date;
}): DeclaredCompositionReport;
/** Emit focused scan findings from the same pure composition analysis. */
export declare function declaredCompositionFindings(catalog: Catalog, evaluationDate: string): Finding[];
/** Aggregate scan findings while retaining at most one complete root report. */
export declare function analyzeDeclaredCompositionFindings(catalog: Catalog, evaluationDate: string): DeclaredCompositionFindingAnalysis;
/** Resolve one explicit composition declaration for impact index preparation. */
export declare function resolveCompositionDeclaration(index: DeclaredCompositionIndex, dependency: Dependency): ResolvedCompositionDeclaration | undefined;