import { $ as BreakingChangeCategory, At as CompatSourceKind, Bt as CompatPolicyHints, Ct as OverlayLookup, Dt as CompatParameter, Et as ViolationSeverity, Ft as CompatVisibility, Ht as mergePolicy, It as LanguageId, Lt as ParameterSensitivity, Mt as CompatSymbol, Nt as CompatSymbolKind, Ot as CompatPassingStyle, Pt as CompatTypeRef, Q as AdditiveChangeCategory, Rt as apiSurfaceToSnapshot, St as MethodOverlay, Tt as ViolationCategory, Vt as getDefaultPolicy, _t as ApiSurface, at as CompatProvenance, bt as Extractor, ct as severityMeetsThreshold, dt as ApiEnum, et as CompatApproval, ft as ApiField, gt as ApiProperty, ht as ApiParam, it as CompatFailLevel, jt as CompatStability, kt as CompatSnapshot, lt as Addition, mt as ApiMethod, nt as CompatChangeSeverity, ot as SoftRiskChangeCategory, pt as ApiInterface, rt as CompatConfig, st as defaultSeverityForCategory, t as ApiSpec, tt as CompatChangeCategory, ut as ApiClass, vt as ApiTypeAlias, wt as Violation, xt as LanguageHints, yt as DiffResult, zt as ALL_LANGUAGE_IDS } from "../types-nM5Kp7UP.mjs";
import { a as specDerivedEnumValues, c as specDerivedMethodPaths, d as ClassifiedChange, f as classifyAddedSymbol, i as filterSurface, l as specDerivedNames, m as summarizeChanges, n as diffSnapshots, o as specDerivedFieldPaths, p as classifySymbolChanges, r as diffSurfaces, s as specDerivedHttpKeys, t as CompatDiffResult, u as ClassificationResult } from "../differ-DMmw0tbA.mjs";

//#region src/compat/schema.d.ts
/** Current schema version for compatibility snapshots. */
declare const COMPAT_SCHEMA_VERSION = "1";
/** Validate that a parsed snapshot has a compatible schema version. */
declare function isCompatibleSchemaVersion(snapshot: {
  schemaVersion?: string;
}): boolean;
/** Validate the basic structure of a parsed compat snapshot. */
declare function validateSnapshot(data: unknown): data is CompatSnapshot;
//#endregion
//#region src/compat/concepts.d.ts
/** A conceptual change with per-language severity. */
interface ConceptualChange {
  /** Deterministic ID from symbol + category + match details. */
  id: string;
  /** IR-level symbol path (language-neutral). */
  symbol: string;
  /** The kind of change. */
  category: CompatChangeCategory;
  /** Per-language severity mapping. */
  impact: Partial<Record<LanguageId, CompatChangeSeverity>>;
  /** Human-readable description (from first language that reported it). */
  message: string;
  /** Old state details. */
  old: Record<string, string>;
  /** New state details. */
  new: Record<string, string>;
}
/** Cross-language conceptual rollup. */
interface ConceptualRollup {
  conceptualChanges: ConceptualChange[];
}
/**
 * Group classified changes from multiple languages into conceptual changes.
 *
 * Changes are grouped by their `conceptualChangeId` — a deterministic ID
 * derived from the symbol, category, and match details. Changes with the
 * same ID across different languages represent the same conceptual change.
 */
declare function buildConceptualRollup(perLanguageResults: Array<{
  diff: CompatDiffResult;
  language: LanguageId;
}>): ConceptualRollup;
/** Get the highest severity across all languages for a conceptual change. */
declare function highestSeverity(change: ConceptualChange): CompatChangeSeverity;
/** Count conceptual changes by highest severity. */
declare function summarizeConceptualChanges(rollup: ConceptualRollup): {
  breaking: number;
  softRisk: number;
  additive: number;
};
//#endregion
//#region src/compat/report.d.ts
/** Machine-readable compat report for a single language. */
interface CompatReport {
  schemaVersion: string;
  language: string;
  summary: {
    breaking: number;
    softRisk: number;
    additive: number;
  };
  changes: CompatReportChange[];
}
/** A single change entry in the machine-readable report. */
interface CompatReportChange {
  severity: CompatChangeSeverity;
  category: CompatChangeCategory;
  symbol: string;
  conceptualChangeId: string;
  provenance: CompatProvenance;
  old: Record<string, string>;
  new: Record<string, string>;
  message?: string;
  /** Spec-level remediation hint when a recognized upstream pattern was detected. */
  remediation?: string;
}
/** Generate a machine-readable compat report from a diff result. */
declare function generateReport(diff: CompatDiffResult, language?: string): CompatReport;
/** Generate a human-readable summary string for terminal output. */
declare function formatHumanSummary(diff: CompatDiffResult, opts?: {
  explain?: boolean;
  language?: string;
}): string;
/** Conceptual cross-language report. */
interface ConceptualReport {
  conceptualChanges: {
    id: string;
    symbol: string;
    category: CompatChangeCategory;
    impact: Partial<Record<LanguageId, CompatChangeSeverity>>;
  }[];
}
/** Generate a conceptual cross-language report from multiple per-language results. */
declare function generateConceptualReport(perLanguageResults: Array<{
  diff: CompatDiffResult;
  language: LanguageId;
}>): ConceptualReport;
/** Format a conceptual cross-language summary for terminal output. */
declare function formatConceptualSummary(perLanguageResults: Array<{
  diff: CompatDiffResult;
  language: LanguageId;
}>): string;
//#endregion
//#region src/compat/approvals.d.ts
/** Result of matching a change against approvals. */
interface ApprovalMatch {
  /** The change that was matched. */
  change: ClassifiedChange;
  /** The approval that matched. null if no approval covers this change. */
  approval: CompatApproval | null;
  /** Whether the change is covered by an approval. */
  approved: boolean;
}
/** Result of validating an approval for broadness. */
interface ApprovalValidation {
  valid: boolean;
  errors: string[];
}
/** Validate that an approval is narrow enough to be accepted. */
declare function validateApproval(approval: CompatApproval): ApprovalValidation;
/** Validate all approvals in a config. Returns errors keyed by index. */
declare function validateApprovals(approvals: CompatApproval[]): Map<number, string[]>;
/**
 * Match a classified change against a list of approvals.
 * Returns the first matching approval, or null if none match.
 */
declare function matchApproval(change: ClassifiedChange, approvals: CompatApproval[], language: LanguageId): CompatApproval | null;
/**
 * Apply approvals to a list of changes.
 * Returns matches for every change (approved or not).
 */
declare function applyApprovals(changes: ClassifiedChange[], approvals: CompatApproval[], language: LanguageId): ApprovalMatch[];
/**
 * Filter changes to only those NOT covered by approvals.
 * These are the remaining unapproved changes that may cause failure.
 */
declare function unapprovedChanges(changes: ClassifiedChange[], approvals: CompatApproval[], language: LanguageId): ClassifiedChange[];
//#endregion
//#region src/compat/extractor-registry.d.ts
declare function registerExtractor(extractor: Extractor): void;
declare function getExtractor(language: string): Extractor;
//#endregion
//#region src/compat/overlay.d.ts
interface ManifestEntry {
  operationId: string;
  sdkResourceProperty: string;
  sdkMethodName: string;
  httpMethod: string;
  path: string;
  pathParams: string[];
  bodyFields: string[];
  queryFields: string[];
}
declare function buildOverlayLookup(surface: ApiSurface, manifest?: ManifestEntry[], spec?: ApiSpec, hints?: LanguageHints, options?: {
  strictModelMatch?: boolean;
}): OverlayLookup;
/** Check if a classified change is patchable by the overlay loop. */
declare function isPatchableChange(change: ClassifiedChange): boolean;
/**
 * Patch overlay with classified changes from a failed verification.
 * Adds explicit name mappings for symbols that were generated with wrong names.
 * Returns a new OverlayLookup (immutable).
 */
declare function patchOverlay(overlay: OverlayLookup, changes: ClassifiedChange[], baseline: ApiSurface): OverlayLookup;
//#endregion
//#region src/compat/extractors/node.d.ts
declare const nodeExtractor: Extractor;
//#endregion
//#region src/compat/extractors/php.d.ts
/** Default PHP extractor with generic language hints (no SDK-specific bases). */
declare const phpExtractor: Extractor;
//#endregion
//#region src/compat/extractors/python.d.ts
/** Default Python extractor with generic language hints (no SDK-specific bases). */
declare const pythonExtractor: Extractor;
//#endregion
//#region src/compat/extractors/ruby.d.ts
declare const rubyExtractor: Extractor;
//#endregion
//#region src/compat/extractors/go.d.ts
declare const goExtractor: Extractor;
//#endregion
//#region src/compat/extractors/rust.d.ts
declare const rustExtractor: Extractor;
//#endregion
//#region src/compat/extractors/kotlin.d.ts
declare const kotlinExtractor: Extractor;
//#endregion
//#region src/compat/extractors/dotnet.d.ts
/** Default DotNet extractor with generic language hints. */
declare const dotnetExtractor: Extractor;
//#endregion
//#region src/compat/extractors/elixir.d.ts
declare const elixirExtractor: Extractor;
//#endregion
//#region src/compat/language-hints.d.ts
/**
 * Node/TypeScript language hints — reference implementation.
 * Extracted from the hardcoded logic previously in differ.ts and overlay.ts.
 */
declare const nodeHints: LanguageHints;
/**
 * Merge partial language hint overrides over nodeHints defaults.
 * Any hint not provided falls back to the Node/TypeScript implementation.
 */
declare function resolveHints(overrides: Partial<LanguageHints>): LanguageHints;
//#endregion
export { ALL_LANGUAGE_IDS, type Addition, type AdditiveChangeCategory, type ApiClass, type ApiEnum, type ApiField, type ApiInterface, type ApiMethod, type ApiParam, type ApiProperty, type ApiSurface, type ApiTypeAlias, type ApprovalMatch, type ApprovalValidation, type BreakingChangeCategory, COMPAT_SCHEMA_VERSION, type ClassificationResult, type ClassifiedChange, type CompatApproval, type CompatChangeCategory, type CompatChangeSeverity, type CompatConfig, type CompatDiffResult, type CompatFailLevel, type CompatParameter, type CompatPassingStyle, type CompatPolicyHints, type CompatProvenance, type CompatReport, type CompatReportChange, type CompatSnapshot, type CompatSourceKind, type CompatStability, type CompatSymbol, type CompatSymbolKind, type CompatTypeRef, type CompatVisibility, type ConceptualChange, type ConceptualReport, type ConceptualRollup, type DiffResult, type Extractor, type LanguageHints, type LanguageId, type MethodOverlay, type OverlayLookup, type ParameterSensitivity, type SoftRiskChangeCategory, type Violation, type ViolationCategory, type ViolationSeverity, apiSurfaceToSnapshot, applyApprovals, buildConceptualRollup, buildOverlayLookup, classifyAddedSymbol, classifySymbolChanges, defaultSeverityForCategory, diffSnapshots, diffSurfaces, dotnetExtractor, elixirExtractor, filterSurface, formatConceptualSummary, formatHumanSummary, generateConceptualReport, generateReport, getDefaultPolicy, getExtractor, goExtractor, highestSeverity, isCompatibleSchemaVersion, isPatchableChange, kotlinExtractor, matchApproval, mergePolicy, nodeExtractor, nodeHints, patchOverlay, phpExtractor, pythonExtractor, registerExtractor, resolveHints, rubyExtractor, rustExtractor, severityMeetsThreshold, specDerivedEnumValues, specDerivedFieldPaths, specDerivedHttpKeys, specDerivedMethodPaths, specDerivedNames, summarizeChanges, summarizeConceptualChanges, unapprovedChanges, validateApproval, validateApprovals, validateSnapshot };
//# sourceMappingURL=index.d.mts.map