import type { Diagnostic, EdgeKind, Graph, Manifest, OverrideConstraint, PackageMetadataField, TarballKey } from '../graph.js';
import type { FormatId, YarnBerryFormatId } from '../api/format-contract.js';
import type { ConvertCommonOptions, ConvertInput } from '../convert/types.js';
import type { PackumentVersion } from '../registry/types.js';
export type Knowledge = 'none' | 'partial' | 'complete';
export type PolicyKnowledge = 'none' | 'outcome-only' | 'normalized' | 'authored';
export type PeerKnowledge = 'none' | 'declared' | 'resolved' | 'virtualized';
export type LayoutKnowledge = 'none' | 'hints' | 'source-native-encoded' | 'synthesized-by-consumer';
export type ArtifactKnowledge = 'none' | 'identified' | 'metadata' | 'bytes' | 'verified';
export type ManifestKnowledge = 'faithful' | 'extended-unknown' | 'extended-fingerprinted';
export type Verification = 'unverified' | 'graph-validated' | 'target-parse-accepted' | 'mutable-stable' | 'frozen-verified';
export interface CompletenessProfile {
    projectTopology: Knowledge;
    resolvedGraph: Knowledge;
    edgeKinds: Knowledge;
    peerModel: PeerKnowledge;
    resolutionPolicy: PolicyKnowledge;
    manifestKnowledge: ManifestKnowledge;
    packageMetadata: Knowledge;
    artifacts: ArtifactKnowledge;
    layout: LayoutKnowledge;
    verification: Verification;
}
export type CompletenessDimension = keyof CompletenessProfile;
export interface StructuralCoverage extends CompletenessProfile {
}
export interface SourceCapabilityResult {
    readonly floor: Readonly<CompletenessProfile>;
    readonly ambiguousDimensions: ReadonlySet<CompletenessDimension>;
}
export type EvidenceKind = 'lockfile' | 'repository-manifest' | 'pm-config' | 'abbreviated-packument' | 'full-packument' | 'version-manifest' | 'tarball-manifest' | 'artifact-bytes' | 'patch-file' | 'local-directory' | 'installed-state' | 'inference' | 'target-oracle';
export interface EvidenceRef {
    readonly kind: EvidenceKind;
    readonly subject?: string;
    readonly source?: string;
    readonly digest?: string;
    readonly coverage?: ManifestCoverage;
    readonly presence?: 'present' | 'absent';
    readonly manager?: Readonly<{
        name: string;
        version: string;
    }>;
    readonly target?: PinnedTargetRequest;
    readonly platform?: string;
    readonly configDigest?: string;
    readonly inputDigest?: string;
    readonly projectionDigest?: string;
    readonly verification?: OracleVerification;
}
export type TargetManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'deno' | 'lockgraph';
export interface EvidenceLedger {
    readonly source?: Readonly<{
        format: FormatId;
        manager: TargetManager;
        version?: string;
    }>;
    readonly refs: readonly EvidenceRef[];
    readonly diagnostics: readonly Diagnostic[];
}
declare const evidenceContextBrand: unique symbol;
export interface EvidenceContext {
    readonly ledger: EvidenceLedger;
    readonly [evidenceContextBrand]: true;
}
export type ManifestCoverage = 'partial' | 'complete';
export interface RepositoryManifestEvidence {
    readonly kind: 'repository-manifests';
    readonly manifests: Readonly<Record<string, Manifest>>;
    readonly coverage: ManifestCoverage;
}
export interface PmConfigEvidence {
    readonly kind: 'pm-config';
    readonly manager: Exclude<TargetManager, 'lockgraph'>;
    readonly version: string;
    readonly source: string;
    readonly surface: 'overrides';
    readonly coverage: 'complete';
    readonly overrides: readonly OverrideConstraint[];
}
export interface PackageManifestEvidence {
    readonly kind: 'package-manifests';
    readonly authority: 'full-packument' | 'version-manifest' | 'tarball-manifest';
    readonly manifests: Readonly<Record<TarballKey, PackumentVersion>>;
}
export type TargetRequest = Readonly<{
    format: YarnBerryFormatId;
    managerVersion?: string;
    cacheKey?: string;
}> | Readonly<{
    format: Exclude<FormatId, YarnBerryFormatId>;
    managerVersion?: string;
}>;
export type TargetInput = FormatId | TargetRequest;
export type PinnedTargetRequest = TargetRequest & Readonly<{
    managerVersion: string;
}>;
export type OracleVerification = Exclude<Verification, 'unverified' | 'graph-validated'>;
interface TargetOracleEvidenceBase {
    readonly kind: 'target-oracle';
    readonly graph: Graph;
    readonly target: PinnedTargetRequest;
    readonly platform: string;
    readonly configDigest: string;
    readonly inputDigest: string;
}
export type TargetOracleEvidence = TargetOracleEvidenceBase & (Readonly<{
    readonly verification: 'frozen-verified';
    readonly projectionDigest: string;
}> | Readonly<{
    readonly verification: Exclude<OracleVerification, 'frozen-verified'>;
    readonly projectionDigest?: never;
}>);
export interface EvidenceInputMap {
    readonly 'pm-config': PmConfigEvidence;
    readonly 'package-manifests': PackageManifestEvidence;
    readonly 'target-oracle': TargetOracleEvidence;
}
export type EvidenceInput = EvidenceInputMap[keyof EvidenceInputMap];
export interface CompletenessContext {
    readonly evidence?: EvidenceContext;
}
export interface CompletenessResult {
    readonly profile: Readonly<CompletenessProfile>;
    readonly structural: Readonly<StructuralCoverage>;
    readonly evidence: EvidenceContext;
    readonly diagnostics: readonly Diagnostic[];
}
export type CompletenessDiagnosticCode = 'COMPLETENESS_EVIDENCE_CONFLICT' | 'COMPLETENESS_EVIDENCE_SCOPE_MISMATCH' | 'COMPLETENESS_FEATURE_UNMODELED' | 'COMPLETENESS_MANIFEST_EXTENSION_DEPENDENCY_MISMATCH' | 'COMPLETENESS_MANAGER_GENERATION_AMBIGUOUS' | 'COMPLETENESS_PACKAGE_METADATA_INCOMPLETE' | 'COMPLETENESS_PACKAGE_METADATA_MISMATCH' | 'COMPLETENESS_PACKAGE_METADATA_SOURCE_UNSUPPORTED';
export interface CompletenessDiagnostic extends Diagnostic {
    code: CompletenessDiagnosticCode;
}
export type TargetPeerRepresentation = 'none' | 'declared' | 'resolved' | 'virtualized';
export type TargetIntegrityFamily = 'none' | 'tarball-sri' | 'berry-zip' | 'canonical';
export type TargetLayoutCapability = 'none' | 'encoded' | 'generated';
export type OverrideConfigLocation = 'none' | 'manifest' | 'workspace-yaml';
export type OverrideGrammar = 'none' | 'npm-nested' | 'yarn-selective' | 'pnpm-flat' | 'bun-flat';
export interface ResolvedTargetCapabilities {
    readonly edgeKinds: ReadonlySet<EdgeKind>;
    readonly workspaces: boolean;
    readonly workspaceProtocol: boolean;
    readonly peerRepresentation: TargetPeerRepresentation;
    readonly patches: boolean;
    readonly bundledDependencies: boolean;
    readonly conditions: boolean;
    readonly catalogs: boolean;
    readonly integrity: TargetIntegrityFamily;
    readonly layout: TargetLayoutCapability;
    readonly lockOverridesCarrier: boolean;
    readonly overridesConfigLocation: OverrideConfigLocation;
    readonly comparesOverridesInFrozen: boolean;
    readonly overridesGrammar: OverrideGrammar;
    readonly metadataFields: ReadonlySet<PackageMetadataField>;
}
export type TargetCapability = keyof ResolvedTargetCapabilities;
export interface TargetProfile {
    readonly manager: TargetManager;
    readonly format: FormatId;
    readonly managerVersion?: string;
    readonly capabilities: Readonly<ResolvedTargetCapabilities>;
    readonly ambiguousCapabilities: ReadonlySet<TargetCapability>;
    readonly provenance: 'builtin';
}
export type ConversionContract = 'snapshot' | 'policy' | 'project' | 'frozen';
export type RequirementStatus = 'satisfied' | 'unsatisfied' | 'unassessed';
export interface RequirementAssessment {
    readonly key: string;
    readonly dimension?: CompletenessDimension;
    readonly status: RequirementStatus;
    readonly diagnostics: readonly Diagnostic[];
}
export interface ConversionAssessment {
    readonly status: RequirementStatus;
    readonly contract: ConversionContract;
    readonly source: SourceCapabilityResult;
    readonly target: TargetProfile;
    readonly completeness: CompletenessResult;
    readonly requirements: readonly RequirementAssessment[];
    readonly diagnostics: readonly Diagnostic[];
}
export interface AssessmentOptions {
    readonly contract: ConversionContract;
    readonly target: TargetRequest;
    readonly evidence?: EvidenceContext;
}
export interface StringifyAssessedOptions extends Omit<AssessmentOptions, 'target'> {
    readonly target: TargetInput;
    readonly lineEnding?: 'lf' | 'crlf';
    readonly cacheKey?: string;
}
export interface ConvertAssessedOptions {
    readonly to: FormatId;
    readonly from?: FormatId;
    readonly workspaceRoot?: string;
    readonly manifests?: Readonly<Record<string, Manifest>>;
    readonly lineEnding?: 'lf' | 'crlf';
    readonly cacheKey?: string;
    readonly onDiagnostic?: (diagnostic: Diagnostic) => void;
    readonly contract: ConversionContract;
    readonly sourceVersion?: string;
    readonly targetVersion?: string;
    readonly manifestCoverage?: ManifestCoverage;
}
export type ProjectEvidenceInput = Exclude<EvidenceInput, TargetOracleEvidence>;
export interface ConvertProjectOptions extends Omit<ConvertAssessedOptions, 'contract'> {
    readonly evidenceInputs?: readonly (ProjectEvidenceInput | RepositoryManifestEvidence)[];
}
export interface AssessedOutput {
    readonly output?: string;
    readonly assessment: ConversionAssessment;
}
export interface ProjectConversionResult {
    readonly lockfile?: string;
    readonly companions?: readonly CompanionSetOperation[];
    readonly assessment: ConversionAssessment;
}
export interface FrozenVerificationSubject {
    readonly protocol: 'lockgraph-frozen-projection/v1';
    readonly target: PinnedTargetRequest;
    readonly projectionDigest: string;
}
export interface FrozenCandidate extends FrozenVerificationSubject {
    readonly lockfile: string;
    readonly companions: readonly CompanionSetOperation[];
    readonly assessment: ConversionAssessment;
}
export interface FrozenPreparationResult {
    readonly candidate?: FrozenCandidate;
    readonly assessment: ConversionAssessment;
}
export interface FrozenVerificationReceipt extends FrozenVerificationSubject {
    readonly verification: 'frozen-verified';
    readonly platform: string;
    readonly configDigest: string;
    readonly inputDigest: string;
    readonly oracle: Readonly<{
        readonly protocol: 'lockgraph-native-frozen/v1';
        readonly runner: string;
        readonly version: string;
    }>;
}
export interface FrozenConversionResult {
    readonly lockfile?: string;
    readonly companions?: readonly CompanionSetOperation[];
    readonly verification?: FrozenVerificationReceipt;
    readonly assessment: ConversionAssessment;
}
interface FrozenPreparationCommonOptions extends Omit<ConvertCommonOptions, 'strict'> {
    readonly sourceVersion?: string;
    readonly manifestCoverage?: ManifestCoverage;
    readonly evidenceInputs?: readonly (ProjectEvidenceInput | RepositoryManifestEvidence)[];
}
interface FrozenPreparationTargetOptions {
    readonly target: TargetInput;
    readonly to?: never;
    readonly targetVersion?: never;
}
interface LegacyFrozenPreparationTargetOptions {
    readonly target?: never;
    /** @deprecated Use target. */
    readonly to: FormatId;
    /** @deprecated Use target.managerVersion. */
    readonly targetVersion: string;
}
export type FrozenPreparationOptions = FrozenPreparationCommonOptions & (FrozenPreparationTargetOptions | LegacyFrozenPreparationTargetOptions);
export type FrozenInput = ConvertInput;
export interface FrozenOptions extends Omit<import('../api/operation.js').ProjectionOptions, 'target' | 'strict'> {
    readonly target: PinnedTargetRequest;
    readonly sourceFormat?: FormatId;
    readonly fs?: import('../convert/types.js').ConvertFileSystem;
    readonly lineEnding?: 'lf' | 'crlf';
    readonly evidence?: readonly ProjectEvidenceInput[];
}
export type ProjectFrozenOptions = Omit<FrozenOptions, 'sources'> & Readonly<{
    readonly sources?: Omit<import('../api/operation.js').OperationSources, 'manifests'>;
}>;
export interface FrozenCertificationOptions {
    readonly files: import('../api/operation.js').FileSource;
    readonly cwd?: string;
    readonly fs?: import('../convert/types.js').ConvertFileSystem;
    readonly manager: Exclude<import('../api/operation.js').PackageManager, 'lockgraph'>;
    readonly version: string;
    readonly platform?: string;
}
export interface ProjectCompanionOptions {
    readonly target: TargetRequest;
    readonly evidence?: EvidenceContext;
}
export interface CompanionSetOperation {
    readonly path: 'package.json' | 'pnpm-workspace.yaml';
    readonly op: 'set';
    readonly pointer: string;
    readonly value: Readonly<Record<string, unknown>>;
}
export interface ProjectCompanionResult {
    readonly patches?: readonly CompanionSetOperation[];
    readonly requirement: RequirementAssessment;
    readonly target: TargetProfile;
    readonly diagnostics: readonly Diagnostic[];
}
export {};