import type { SkillParentIndex } from "./catalog.js";
import { type HelperCommandLauncher, type HelperInvocationResolution } from "./helper-command-evidence.js";
import { type BuiltInExecutableDependencyAnalyzerId, type ExecutableDependencyCandidate, type ExecutableDependencyRelation } from "./executable-dependency-analyzer.js";
import { type ExecutableSurfaceDependency } from "./executable-dependency-resolution.js";
import type { RepositoryPathState } from "./repository-paths.js";
import type { SecurityPolicyAssetEvidence, SecurityPolicySource } from "./security-policy-inventory.js";
import type { Artifact, ArtifactKind } from "./types/artifact.js";
import type { ParsedDocument } from "./types/metadata.js";
export declare const EXECUTABLE_SURFACE_INVENTORY_SCHEMA: "renma.executable-surface-inventory.v1";
export type ExecutableSurfaceOrigin = "discovered-script" | "resolved-static-invocation";
export type ExecutableSurfaceScope = "skill-local" | "repository-tool" | "noncanonical";
export interface ExecutableSurfaceSecurityPolicy {
    hasEffectivePolicy: boolean;
    policySources: SecurityPolicySource[];
    fingerprint?: string;
}
export type ExecutableInvocationPolicyRelation = "source-artifact" | "owning-skill";
export interface ExecutableInvocationPolicyEvidence {
    relation: ExecutableInvocationPolicyRelation;
    path: string;
    hasEffectivePolicy: boolean;
    policySources: SecurityPolicySource[];
    fingerprint?: string;
}
export type ExecutableInvocationOwningSkillResolution = "not-applicable" | "resolved" | "missing" | "ambiguous";
export interface ExecutableInvocationGovernance {
    owningSkillResolution: ExecutableInvocationOwningSkillResolution;
    policyEvidence: ExecutableInvocationPolicyEvidence[];
    hasEffectivePolicyEvidence: boolean;
    distinctEffectivePolicyFingerprints: string[];
    fingerprint: string;
}
export interface ExecutableSurfaceInvocationGovernanceSummary {
    invocationsWithEffectivePolicyEvidence: number;
    invocationsWithoutEffectivePolicyEvidence: number;
    distinctEffectivePolicyFingerprints: string[];
}
export type StaticInvocationReachability = "direct" | "transitive" | "unreached";
export interface ExecutableSurfaceDependencySummary {
    incomingResolvedDependencyCount: number;
    outgoingResolvedDependencyCount: number;
    staticInvocationReachability: StaticInvocationReachability;
    minimumInvocationDependencyDepth?: number;
}
export interface ExecutableSurfaceEntry {
    path: string;
    scope: ExecutableSurfaceScope;
    origins: ExecutableSurfaceOrigin[];
    artifactKind: ArtifactKind;
    contentClassification: "text" | "binary";
    contentHash?: string;
    owningSkill?: {
        skillDirectory: string;
        entrypointPath?: string;
    };
    interpreterHints: string[];
    shebang?: string;
    reachableFromOwningSkill?: boolean;
    reachabilityDepth?: number;
    staticallyReferenced: boolean;
    staticallyInvoked: boolean;
    referenceCount: number;
    invocationCount: number;
    securityPolicy: ExecutableSurfaceSecurityPolicy;
    invocationGovernance: ExecutableSurfaceInvocationGovernanceSummary;
    dependencyEvidence: ExecutableSurfaceDependencySummary;
    fingerprint: string;
}
export interface ExecutableSurfaceInvocation {
    sourcePath: string;
    line: number;
    snippet: string;
    launcher: HelperCommandLauncher;
    rawTarget: string;
    normalizedTarget?: string;
    sourceSkillDirectory?: string;
    resolution: HelperInvocationResolution;
    targetPathState?: RepositoryPathState;
    occurrenceOrdinal: number;
    governance: ExecutableInvocationGovernance;
}
export interface ExecutableSurfaceInventorySummary {
    totalSurfaces: number;
    skillLocalSurfaces: number;
    repositoryToolSurfaces: number;
    noncanonicalSurfaces: number;
    textSurfaces: number;
    binarySurfaces: number;
    reachableSkillLocalSurfaces: number;
    unreachableSkillLocalSurfaces: number;
    referencedSurfaces: number;
    unreferencedSurfaces: number;
    invokedSurfaces: number;
    uninvokedSurfaces: number;
    surfacesWithEffectivePolicy: number;
    surfacesWithoutEffectivePolicy: number;
    totalInvocations: number;
    resolvedInvocations: number;
    missingInvocations: number;
    unsafeInvocations: number;
    unscopedInvocations: number;
    noncanonicalInvocations: number;
    unavailableInvocations: number;
    invocationsWithEffectivePolicyEvidence: number;
    invocationsWithoutEffectivePolicyEvidence: number;
    resolvedInvocationsWithEffectivePolicyEvidence: number;
    resolvedInvocationsWithoutEffectivePolicyEvidence: number;
    invocationsWithMultipleEffectivePolicyFingerprints: number;
    invocationPolicyEvidenceRelations: {
        sourceArtifact: number;
        owningSkill: number;
    };
    totalDependencies: number;
    resolvedDependencies: number;
    missingDependencies: number;
    unsafeDependencies: number;
    ambiguousDependencies: number;
    noncanonicalDependencies: number;
    notInventoryDependencies: number;
    unavailableDependencies: number;
    surfacesWithIncomingDependencies: number;
    surfacesWithOutgoingDependencies: number;
    directlyInvokedSurfaces: number;
    transitivelyReachableSurfaces: number;
    unreachedFromInvocationSurfaces: number;
    dependencyAnalyzers: Array<{
        analyzer: BuiltInExecutableDependencyAnalyzerId;
        count: number;
    }>;
    dependencyRelations: Array<{
        relation: ExecutableDependencyRelation;
        count: number;
    }>;
    interpreterHints: Array<{
        interpreter: string;
        count: number;
    }>;
}
export interface ExecutableSurfaceInventory {
    schema: typeof EXECUTABLE_SURFACE_INVENTORY_SCHEMA;
    summary: ExecutableSurfaceInventorySummary;
    surfaces: ExecutableSurfaceEntry[];
    invocations: ExecutableSurfaceInvocation[];
    dependencies: ExecutableSurfaceDependency[];
}
export interface ExecutableInvocationGraphEdge {
    sourcePath: string;
    normalizedTarget: string;
}
/** Collapse invocation declarations into deterministic source-target graph edges. */
export declare function canonicalExecutableInvocationGraphEdges(invocations: readonly ExecutableSurfaceInvocation[]): ExecutableInvocationGraphEdge[];
export interface ExecutableSurfaceInventoryInput {
    artifacts: Artifact[];
    documents: ParsedDocument[];
    repositoryPaths: ReadonlySet<string>;
    repositoryPathStates: ReadonlyMap<string, RepositoryPathState>;
    incompleteSupportDirectories?: ReadonlySet<string>;
    skillParents: SkillParentIndex;
    securityPolicies: readonly SecurityPolicyAssetEvidence[];
    dependencyCandidates?: readonly ExecutableDependencyCandidate[];
}
/** Build a non-executing inventory from evidence already collected by Renma. */
export declare function buildExecutableSurfaceInventory(input: ExecutableSurfaceInventoryInput): ExecutableSurfaceInventory;
export declare function zeroExecutableSurfaceInventory(): ExecutableSurfaceInventory;
export declare function summarizeExecutableSurfaceInventory(surfaces: readonly ExecutableSurfaceEntry[], invocations: readonly ExecutableSurfaceInvocation[], dependencies?: readonly ExecutableSurfaceDependency[]): ExecutableSurfaceInventorySummary;