import { type AgentSkillsValidationSummary } from "./agent-skills.js";
import { type CanonicalSkillPublicationFieldState } from "./metadata.js";
import type { AssetKind, AssetStatus, Catalog } from "./model.js";
import type { AssetOwnership } from "./types/governance.js";
import type { Diagnostic, Evidence } from "./types/diagnostics.js";
import type { ParsedDocument } from "./types/metadata.js";
export declare const SKILL_ROUTE_USABILITY_REASONS: readonly ["invalid-source", "invalid-target", "inactive-source", "inactive-target", "duplicate-source-id", "duplicate-target-id", "wrong-kind", "ambiguous-target", "unresolved-target", "duplicate-declaration"];
export type SkillRouteUsabilityReason = (typeof SKILL_ROUTE_USABILITY_REASONS)[number];
export type SkillRouteResolutionState = "resolved" | "unresolved" | "ambiguous" | "wrong-kind";
export type SkillRouteNormalizationRejection = "absolute-path" | "repository-escape";
export interface SkillDiagnosticLink {
    code: string;
    evidence?: Evidence;
}
export declare const SKILL_PUBLICATION_REJECTION_REASONS: readonly ["invalid-marker", "ambiguous-marker", "invalid-skill", "inactive-skill", "duplicate-skill-id"];
export type SkillPublicationRejectionReason = (typeof SKILL_PUBLICATION_REJECTION_REASONS)[number];
export interface SkillPublicationMarker {
    state: CanonicalSkillPublicationFieldState;
    canonicalKey: "metadata.renma.published-entrypoint";
    present: boolean;
    valid: boolean;
    rawValue?: unknown;
    evidence?: Evidence;
    reason?: string;
}
export interface SkillPublicationState {
    marker: SkillPublicationMarker;
    requested: boolean;
    accepted: boolean;
    rejectionReasons: SkillPublicationRejectionReason[];
    linkedDiagnostics: SkillDiagnosticLink[];
}
export type SkillDiscoveryReachabilityState = "reachable" | "not-reached" | "not-evaluated";
export type SkillDiscoveryReachabilityReason = "published-entrypoint" | "reachable-through-usable-route" | "no-usable-path-from-published-entrypoint" | "skill-not-discovery-eligible" | "coverage-not-evaluated";
export interface SkillDiscoveryReachability {
    state: SkillDiscoveryReachabilityState;
    reason: SkillDiscoveryReachabilityReason;
    sourceEntrypointIds: string[];
    minimumDepth?: number;
}
export interface VisibleSkillIdentity {
    /** Path-based identity remains authoritative even when the visible ID is duplicated. */
    identity: string;
    id: string;
    sourcePath: string;
    name?: string;
    description?: string;
    lifecycle?: AssetStatus;
    lifecycleReason?: string;
    lifecycleChangedAt?: string;
    ownership: AssetOwnership;
    agentSkillsValid: boolean;
    lifecycleActive: boolean;
    effectiveIdUnique: boolean;
    routeEligible: boolean;
    routeEligibilityReasons: SkillRouteUsabilityReason[];
    publication: SkillPublicationState;
    structuralRoot: boolean;
    standalone: boolean;
    unrouted: boolean;
    reachability: SkillDiscoveryReachability;
    linkedDiagnostics: SkillDiagnosticLink[];
}
export interface SkillRouteCandidateIdentity {
    id: string;
    sourcePath: string;
    kind: AssetKind;
    lifecycle?: AssetStatus;
    lifecycleReason?: string;
    lifecycleChangedAt?: string;
    matchedBy: Array<"id" | "path">;
}
export interface ResolvedSkillRouteTarget {
    id: string;
    sourcePath: string;
    kind: AssetKind;
    lifecycle?: AssetStatus;
    lifecycleReason?: string;
    lifecycleChangedAt?: string;
    effectiveIdUnique: boolean;
    agentSkillsValid?: boolean;
}
export interface SkillRouteDeclarationEvidence extends Evidence {
    metadataKey: "metadata.renma.continues-with";
    declarationIndex: number;
}
export interface DeclaredSkillRoute {
    sourceId: string;
    sourcePath: string;
    declarationIndex: number;
    rawTarget: string;
    normalizedTarget: string;
    normalizationRejection?: SkillRouteNormalizationRejection;
    resolution: SkillRouteResolutionState;
    candidates: SkillRouteCandidateIdentity[];
    resolvedTarget?: ResolvedSkillRouteTarget;
    usable: boolean;
    usabilityReasons: SkillRouteUsabilityReason[];
    representative: boolean;
    duplicateDeclarationIndices: number[];
    evidence: SkillRouteDeclarationEvidence;
    linkedDiagnostics: SkillDiagnosticLink[];
}
export interface SkillDiscoveryRouteCycleSkill {
    id: string;
    sourcePath: string;
}
export interface SkillDiscoveryRouteCycleRoute {
    sourceId: string;
    sourcePath: string;
    targetId: string;
    targetPath: string;
    declarationIndex: number;
    evidence: SkillRouteDeclarationEvidence;
}
/** One maximal cyclic component in the authoritative usable continuation graph. */
export interface SkillDiscoveryRouteCycle {
    cycleSkillIds: string[];
    cycleSkills: SkillDiscoveryRouteCycleSkill[];
    selfLoop: boolean;
    cycleRoutes: SkillDiscoveryRouteCycleRoute[];
}
export interface SkillDiscoverySummary {
    visibleSkillCount: number;
    routeEligibleSkillCount: number;
    declaredRouteCount: number;
    usableRouteCount: number;
    unresolvedRouteCount: number;
    ambiguousRouteCount: number;
    unresolvedOrAmbiguousRouteCount: number;
    invalidRouteCount: number;
    structuralRootCount: number;
    standaloneSkillCount: number;
    unroutedSkillCount: number;
    publishedEntrypointCount: number;
    reachableSkillCount: number;
    notReachedSkillCount: number;
}
export type SkillDiscoveryAdoptionState = "not-adopted" | "partial" | "incomplete" | "adopted";
export interface SkillDiscoveryAdoption {
    state: SkillDiscoveryAdoptionState;
    discoveryMetadataPresent: boolean;
    repositoryWideAdopted: boolean;
    publishedEntrypointCount: number;
    reason: "no-discovery-metadata-or-repository-adoption" | "discovery-metadata-present-without-repository-adoption" | "repository-adoption-has-no-effective-published-entrypoint" | "repository-adoption-has-effective-published-entrypoint";
    configPath?: string;
}
interface SkillDiscoveryCoverageBase {
    scope: "repository";
    sourceEntrypointIds: string[];
    eligibleSkillCount: number;
    reachableSkillCount: number;
    notReachedSkillCount: number;
}
export type SkillDiscoveryCoverage = (SkillDiscoveryCoverageBase & {
    mode: "not-evaluated";
    reason: "discovery-not-adopted" | "no-effective-published-entrypoint";
    complete: null;
}) | (SkillDiscoveryCoverageBase & {
    mode: "descriptive";
    reason: "partial-adoption-with-effective-published-entrypoint";
    complete: null;
}) | (SkillDiscoveryCoverageBase & {
    mode: "authoritative";
    reason: "repository-wide-discovery-adopted";
    complete: boolean;
});
export interface SkillDiscoveryReachabilityResolution {
    coverage: SkillDiscoveryCoverage;
    reachabilityBySkillId: ReadonlyMap<string, SkillDiscoveryReachability>;
    reachableDiscoveryEligibleSkillIds: string[];
    notReachedDiscoveryEligibleSkillIds: string[];
}
/** Warning diagnostic emitted from explicit Skill continuation evidence. */
export type SkillDiscoveryDiagnostic = Diagnostic;
export interface SkillDiscoveryIndex {
    skills: VisibleSkillIdentity[];
    routes: DeclaredSkillRoute[];
    adoption: SkillDiscoveryAdoption;
    coverage: SkillDiscoveryCoverage;
    publishedEntrypointIds: string[];
    reachableDiscoveryEligibleSkillIds: string[];
    notReachedDiscoveryEligibleSkillIds: string[];
    structuralRootIds: string[];
    standaloneSkillIds: string[];
    unroutedSkillIds: string[];
    summary: SkillDiscoverySummary;
    diagnostics: SkillDiscoveryDiagnostic[];
    focus?: {
        id: string;
        sourcePath: string;
    };
}
export interface SkillDiscoveryPreparationOptions {
    repositoryWideAdopted?: boolean;
    configPath?: string;
}
interface NormalizedTarget {
    value: string;
    rejection?: SkillRouteNormalizationRejection;
}
/** Build one deterministic static Skill continuation index from prepared repository data. */
export declare function prepareSkillDiscoveryIndex(documents: ParsedDocument[], catalog: Catalog, agentSkills?: AgentSkillsValidationSummary, options?: SkillDiscoveryPreparationOptions): SkillDiscoveryIndex;
/** Resolve an exact Skill focus and retain only its direct declared neighborhood. */
export declare function focusSkillDiscoveryIndex(index: SkillDiscoveryIndex, focus: string, commandName?: "graph" | "skill-index"): SkillDiscoveryIndex;
/**
 * Resolve maximal cyclic components from the already authoritative usable
 * Skill continuation graph. This pure helper does not reinterpret usability,
 * reachability, or repository evidence.
 */
export declare function resolveSkillDiscoveryRouteCycles(routes: readonly DeclaredSkillRoute[]): SkillDiscoveryRouteCycle[];
/** Apply the reviewed target spelling normalization without fuzzy matching. */
export declare function normalizeSkillRouteTarget(target: string): NormalizedTarget;
export {};