@adcp/sdk 14.0.0-rc.37 → 14.0.0-rc.39

package/dist/lib/registry/types.generated.d.ts

@@ -1364,7 +1364,7 @@ export interface paths {
         };
         /**
          * Get agent compliance detail
-         * @description Returns detailed compliance status for a single agent, including track-level results, storyboard counts, and timestamps.
+         * @description Returns detailed compliance status for a single agent, including track-level results, storyboard counts, timestamps, and owner-only grading comparisons. Exact badge-scope rows compare Legacy and Strict Spec grading for one role/version; Sandbox remains preview-only. Reading never contacts the agent.
          *
          *     If the agent has opted out of compliance monitoring, returns a minimal response with `status: opted_out`.
          */
@@ -1377,6 +1377,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/registry/agents/{encodedUrl}/grading-profile": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Select an exact badge grading profile
+         * @description Selects Legacy or Strict Spec grading for one exact agent role and AdCP version. Requires a current immutable assessment, organization owner/admin authorization, revision compare-and-swap, and an idempotency key. Sandbox is preview-only. The selection itself does not contact the agent.
+         */
+        put: operations["selectAgentGradingProfile"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/.well-known/jwks.json": {
         parameters: {
             query?: never;
@@ -1740,7 +1760,7 @@ export interface paths {
          *
          *     **Compliance re-run:** when the caller owns the agent or is an AAO admin and the capability probe succeeds, the full storyboard suite can run for several minutes on capability-rich agents with a fresh test session, and `agent_storyboard_status` is updated. Owner-triggered runs use `triggered_by: 'owner_test'`; admin-triggered support runs use `triggered_by: 'manual'`. Badge fan-out reissues verification badges off the new run. If the compliance call fails (timeout, OAuth wall, internal error), the capability/health portion still returns successfully — `compliance.ran` is `false` with an `error` string.
          *
-         *     **Auth:** owner of the agent, AAO admin, or static `ADMIN_API_KEY`.
+         *     **Auth:** owner of the agent, AAO admin, or static `ADMIN_API_KEY`. Human submissions are temporarily fenced with HTTP 503 until durable authorization provenance is supported; static admin API key submissions remain available.
          *
          *     **Rate limits:** 60 seconds per agent URL, 30 requests per user per hour.
          */
@@ -4131,6 +4151,20 @@ export interface components {
             adcp_version?: string | null;
             /** @enum {string} */
             status: "passing" | "degraded" | "failing" | "unknown" | "opted_out";
+            /** @description Public exact role/version status for every explicit grading selection. This is authoritative for the selected badge identity; the top-level status remains the agent-wide compliance summary. */
+            selected_grading_statuses?: {
+                role: components["schemas"]["BadgeRole"];
+                adcp_version: string;
+                /** @enum {string} */
+                grading_profile: "legacy" | "spec";
+                /** @enum {string|null} */
+                grading_status: "passing" | "partial" | "failing" | null;
+                /** @enum {string} */
+                availability: "current" | "unavailable";
+                /** @enum {string|null} */
+                badge_status: "active" | "degraded" | "revoked" | null;
+                revision: string;
+            }[];
             /** @enum {string} */
             lifecycle_stage: "development" | "testing" | "production" | "deprecated";
             compliance_opt_out?: boolean;
@@ -4210,6 +4244,8 @@ export interface components {
             verdict_source?: "heartbeat" | "owner_test" | "manual" | "webhook" | null;
             verified?: boolean;
             verified_badges?: components["schemas"]["VerificationBadge"][];
+            /** @description Owner/admin-only comparisons from one source run. Exact badge-scope rows allow Legacy or Strict Spec selection; Sandbox remains preview-only. Empty for other viewers. Reading never contacts the agent. */
+            grading_profile_comparisons?: components["schemas"]["GradingProfileComparison"][];
         };
         PublicComplianceNotice: {
             severity: string;
@@ -4229,12 +4265,196 @@ export interface components {
             verified_at: string;
             /** @description Specialisms demonstrably passed (enums/specialism.json). Preview specialisms are excluded from stable badges. */
             verified_specialisms: ("audience-sync" | "brand-rights" | "buyer-activation" | "buyer-discovery" | "buyer-monitoring" | "buyer-negotiation" | "buyer-recovery" | "collection-lists" | "content-standards" | "creative-ad-server" | "creative-generative" | "creative-template" | "creative-transformers" | "governance-aware-seller" | "governance-delivery-monitor" | "governance-spend-authority" | "property-lists" | "sales-broadcast-tv" | "sales-catalog-driven" | "sales-dooh" | "sales-guaranteed" | "sales-non-guaranteed" | "sales-proposal-mode" | "sales-social" | "signal-marketplace" | "orchestrator-multi-agent" | "signal-owned" | "signed-requests" | "sponsored-intelligence")[];
-            /** @description Verification axes earned. 'spec' = AdCP storyboards pass for the declared specialisms. 'live' = AAO has observed real production traffic via canonical campaigns. Always non-empty when a badge is present; an absent badge is conveyed by the parent record being omitted, not by an empty array. */
+            /** @description Evidence modes earned. 'spec' = AdCP storyboards were exercised; 'live' = production traffic was observed. Independent of grading_profile and always non-empty when a badge is present. */
             verification_modes: ("spec" | "live")[];
+            /**
+             * @description Grading profile that produced the public badge. 'spec' means Strict Spec grading; this is independent of the 'spec' evidence mode.
+             * @enum {string}
+             */
+            grading_profile: "legacy" | "spec";
+            grading_profile_revision?: number;
+            /**
+             * Format: date-time
+             * @description Start of the current Strict Spec failure episode. Null when no Strict Spec failure clock is active.
+             */
+            first_failing_spec_at?: string | null;
             verified_protocol_version: string | null;
             /** @description Legacy URL — auto-upgrades to the highest active version. For version-pinned embedding, derive `/api/registry/agents/{encoded_url}/badge/{role}/{adcp_version}.svg` where `{encoded_url}` is `encodeURIComponent(agent_url)`. */
             badge_url?: string;
         };
+        GradingProfileComparison: {
+            role?: components["schemas"]["BadgeRole"];
+            adcp_version?: string;
+            /** @enum {string} */
+            availability: "current" | "stale" | "pending" | "temporarily_unavailable";
+            unavailable_reason: string | null;
+            /** @enum {string} */
+            selected_profile: "legacy" | "spec";
+            selection_enabled: boolean;
+            selection_revision?: number;
+            /** Format: date-time */
+            first_failing_spec_at?: string | null;
+            /** Format: date-time */
+            legacy_selection_allowed_until?: string | null;
+            /** Format: uuid */
+            source_run_id?: string;
+            evaluator_policy_version?: string;
+            requested_compliance_target?: string | null;
+            compliance_bundle_version: string | null;
+            /** Format: date-time */
+            assessed_at?: string | null;
+            /** Format: date-time */
+            source_tested_at?: string | null;
+            stale?: boolean;
+            incomplete?: boolean;
+            public_impact?: string;
+            profiles: {
+                legacy: {
+                    available: boolean;
+                    /** @enum {string|null} */
+                    status: "passing" | "partial" | "failing" | null;
+                    /** @enum {string|null} */
+                    observed_status: "passing" | "partial" | "failing" | null;
+                    explanation: string;
+                    /** Format: uuid */
+                    assessment_id?: string;
+                    selectable?: boolean;
+                    /** @enum {string} */
+                    public_effect?: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                    /** Format: date-time */
+                    grace_deadline?: string | null;
+                };
+                spec: {
+                    available: boolean;
+                    /** @enum {string|null} */
+                    status: "passing" | "partial" | "failing" | null;
+                    /** @enum {string|null} */
+                    observed_status: "passing" | "partial" | "failing" | null;
+                    explanation: string;
+                    /** Format: uuid */
+                    assessment_id?: string;
+                    selectable?: boolean;
+                    /** @enum {string} */
+                    public_effect?: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                    /** Format: date-time */
+                    grace_deadline?: string | null;
+                };
+                sandbox: {
+                    available: boolean;
+                    /** @enum {string|null} */
+                    status: "passing" | "partial" | "failing" | null;
+                    /** @enum {string|null} */
+                    observed_status: "passing" | "partial" | "failing" | null;
+                    explanation: string;
+                    /** Format: uuid */
+                    assessment_id?: string;
+                    selectable?: boolean;
+                    /** @enum {string} */
+                    public_effect?: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                    /** Format: date-time */
+                    grace_deadline?: string | null;
+                };
+            } | null;
+            /** @enum {string} */
+            scope: "agent";
+            evidence?: {
+                run_complete: boolean;
+                bundle_evidence_present: boolean;
+                selected_storyboard_count: number;
+                controller_gap_phase_count: number;
+                observed_failure_count: number;
+                flat_failure_count: number;
+                unattributed_failure_count: number;
+                sandbox_unresolved_bundle_count: number;
+            };
+        } | {
+            role: components["schemas"]["BadgeRole"];
+            adcp_version: string;
+            /** @enum {string} */
+            availability: "current" | "stale" | "pending" | "temporarily_unavailable";
+            unavailable_reason: string | null;
+            /** @enum {string} */
+            selected_profile: "legacy" | "spec";
+            selection_enabled: boolean;
+            selection_revision?: number;
+            /** Format: date-time */
+            first_failing_spec_at?: string | null;
+            /** Format: date-time */
+            legacy_selection_allowed_until?: string | null;
+            /** Format: uuid */
+            source_run_id: string;
+            evaluator_policy_version: string;
+            requested_compliance_target?: string | null;
+            compliance_bundle_version: string;
+            /** Format: date-time */
+            assessed_at?: string | null;
+            /** Format: date-time */
+            source_tested_at?: string | null;
+            stale?: boolean;
+            incomplete?: boolean;
+            public_impact?: string;
+            profiles: {
+                legacy: {
+                    available: boolean;
+                    /** @enum {string|null} */
+                    status: "passing" | "partial" | "failing" | null;
+                    /** @enum {string|null} */
+                    observed_status: "passing" | "partial" | "failing" | null;
+                    explanation: string;
+                    /** Format: uuid */
+                    assessment_id?: string;
+                    selectable?: boolean;
+                    /** @enum {string} */
+                    public_effect?: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                    /** Format: date-time */
+                    grace_deadline?: string | null;
+                };
+                spec: {
+                    available: boolean;
+                    /** @enum {string|null} */
+                    status: "passing" | "partial" | "failing" | null;
+                    /** @enum {string|null} */
+                    observed_status: "passing" | "partial" | "failing" | null;
+                    explanation: string;
+                    /** Format: uuid */
+                    assessment_id?: string;
+                    selectable?: boolean;
+                    /** @enum {string} */
+                    public_effect?: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                    /** Format: date-time */
+                    grace_deadline?: string | null;
+                };
+                sandbox: {
+                    available: boolean;
+                    /** @enum {string|null} */
+                    status: "passing" | "partial" | "failing" | null;
+                    /** @enum {string|null} */
+                    observed_status: "passing" | "partial" | "failing" | null;
+                    explanation: string;
+                    /** Format: uuid */
+                    assessment_id?: string;
+                    selectable?: boolean;
+                    /** @enum {string} */
+                    public_effect?: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                    /** Format: date-time */
+                    grace_deadline?: string | null;
+                };
+            } | null;
+            /** @enum {string} */
+            scope: "badge";
+            evidence: {
+                specialisms: string[];
+                relevant_bundle_count: number;
+                relevant_bundle_ids: string[];
+                failing_bundle_count: number;
+                incomplete_bundle_count: number;
+                relevant_failure_count: number;
+                missing_universal_bundle: boolean;
+                missing_protocol_bundle: boolean;
+                missing_specialism_bundles: string[];
+                evaluator: string;
+            };
+        };
         AgentVerification: {
             agent_url: string;
             verified: boolean;
@@ -6233,7 +6453,7 @@ export interface operations {
                     };
                 };
             };
-            /** @description Publisher crawl is temporarily busy */
+            /** @description Publisher crawl is temporarily busy, or administrator authorization could not be checked */
             503: {
                 headers: {
                     /** @description Seconds to wait before retrying */
@@ -6242,6 +6462,10 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
+                        /** @enum {string} */
+                        error: "admin_authorization_unavailable";
+                        message: string;
+                    } | {
                         error: string;
                         /** @enum {string} */
                         code: "publisher_crawl_busy";
@@ -6338,6 +6562,20 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
+            /** @description Administrator authorization could not be checked */
+            503: {
+                headers: {
+                    "Retry-After": string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        error: "admin_authorization_unavailable";
+                        message: string;
+                    };
+                };
+            };
         };
     };
     lookupPublisherAgentAuthorization: {
@@ -6477,6 +6715,13 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
+                        /**
+                         * @description Canonical supply-path evaluator semantics; pinned by the shared supply-path golden vectors.
+                         * @enum {string}
+                         */
+                        semantics_version: "1";
+                        /** @description Concrete collection chosen for the complete path, including domain-level inquiries. */
+                        resolved_collection_id?: string;
                         /** @enum {string} */
                         state: "verified_owner_sold" | "host_delegated" | "owner_attested" | "unverified";
                         legs: {
@@ -6531,6 +6776,12 @@ export interface operations {
                         agent_url: string;
                         collection_id?: string;
                         sources: {
+                            /** Format: date-time */
+                            owner_fetched_at: string | null;
+                            /** Format: date-time */
+                            host_fetched_at: string | null;
+                            owner_resolved_url: string | null;
+                            host_resolved_url: string | null;
                             owner_adagents_url: string;
                             host_adagents_url: string;
                             /** @description true: manifests came from the registry's crawl cache. Re-derive from the URLs above for enforcement. */
@@ -8466,7 +8717,7 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description Crawl status is temporarily unavailable */
+            /** @description Crawl status or administrator authorization is temporarily unavailable */
             503: {
                 headers: {
                     /** @description Seconds to wait before retrying */
@@ -8475,6 +8726,10 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
+                        /** @enum {string} */
+                        error: "admin_authorization_unavailable";
+                        message: string;
+                    } | {
                         error: string;
                         /** @enum {string} */
                         code: "crawl_status_unavailable";
@@ -8657,6 +8912,102 @@ export interface operations {
             };
         };
     };
+    selectAgentGradingProfile: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description URL-encoded agent URL */
+                encodedUrl: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    organization_id: string;
+                    role: components["schemas"]["BadgeRole"];
+                    adcp_version: string;
+                    /** @enum {string} */
+                    selected_profile: "legacy" | "spec";
+                    /** Format: uuid */
+                    assessment_id: string;
+                    expected_revision: number;
+                    acknowledge_public_impact?: boolean;
+                    /** Format: uuid */
+                    idempotency_key: string;
+                    admin_override_reason?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Selection committed and audited */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        selected_profile: "legacy" | "spec";
+                        revision: string;
+                        /** @enum {string} */
+                        public_effect: "unchanged" | "issue" | "restore" | "regrade" | "degrade" | "revoke";
+                        replayed: boolean;
+                        /** Format: uuid */
+                        source_run_id: string;
+                        /** @enum {string} */
+                        token_refresh: "completed" | "scheduled";
+                    };
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Organization owner/admin required */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Stale assessment/revision, disabled selection, or impact confirmation required */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     getJwks: {
         parameters: {
             query?: never;
@@ -8811,6 +9162,8 @@ export interface operations {
                         agent_url: string;
                         role: components["schemas"]["BadgeRole"];
                         verified: boolean;
+                        /** @enum {string} */
+                        grading_profile: "legacy" | "spec";
                         adcp_version?: string;
                         badge_svg_url: string;
                         registry_url: string;
@@ -8938,6 +9291,8 @@ export interface operations {
                         agent_url: string;
                         role: components["schemas"]["BadgeRole"];
                         verified: boolean;
+                        /** @enum {string} */
+                        grading_profile: "legacy" | "spec";
                         adcp_version: string;
                         badge_svg_url: string;
                         registry_url: string;
@@ -9889,13 +10244,22 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description Durable refresh queue unavailable or at capacity */
+            /** @description Refresh queue or authorization unavailable. All human submissions are temporarily fenced with refresh_authorization_provenance_required; only static admin API key submissions are supported. */
             503: {
                 headers: {
+                    "Retry-After": string;
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["Error"];
+                    "application/json": {
+                        /** @enum {string} */
+                        error: "admin_authorization_unavailable";
+                        message: string;
+                    } | {
+                        error: string;
+                        code: string;
+                        retry_after: number;
+                    };
                 };
             };
         };
@@ -9989,13 +10353,17 @@ export interface operations {
                     };
                 };
             };
-            /** @description Refresh status temporarily unavailable */
+            /** @description Refresh status or administrator authorization temporarily unavailable */
             503: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["Error"];
+                    "application/json": {
+                        /** @enum {string} */
+                        error: "admin_authorization_unavailable";
+                        message: string;
+                    } | components["schemas"]["Error"];
                 };
             };
         };

package/dist/lib/reporting/content-mismatch.d.mts

@@ -0,0 +1,126 @@
+/**
+ * Buyer-side `content_mismatch` detection (AdCP 3.2.0-rc.3).
+ *
+ * `content_mismatch` says: the buyer consumed the exact revision the seller
+ * requires, and its content contradicts a fact the accepted configuration
+ * generation **already fixed**. Every code is decidable from the obligation,
+ * the pinned report definition, and the revision itself — with no reference to
+ * either party's own measurement.
+ *
+ * Two boundaries govern everything below, and both are easy to breach in the
+ * permissive direction:
+ *
+ * 1. **Never a measurement dispute.** A disagreement about *how many
+ *    impressions the seller counted* belongs to `measurement_terms` and
+ *    `makegood_policy`. Nothing here compares a delivered number against a
+ *    buyer-side expectation, and nothing here should be extended to.
+ * 2. **Never fire on evidence you do not have.** A false `content_mismatch` is
+ *    expensive: per `consumer_status_projection` it forces the caller's view to
+ *    `action_required`, and the seller MUST NOT return the period to healthy
+ *    while that statement is the current leaf. So four of the six codes are
+ *    **row-level** predicates that the obligation and revision *metadata*
+ *    cannot decide, and they stay silent unless the caller supplies what it
+ *    actually read. Silence is the safe default; a confident wrong answer is
+ *    not.
+ *
+ * Which codes need row evidence, and why the metadata alone cannot substitute:
+ *
+ * | code | spec predicate | decidable from metadata? |
+ * | --- | --- | --- |
+ * | `scope_media_buy_missing` | a frozen buy is absent from the revision **and not represented by an explicit zero row** | **No.** `reporting-revision.json` defines `media_buy_ids` as the denominator *"inherited from the obligation, including buys with zero rows"*, so comparing the two sets is a tautology against a conformant seller. |
+ * | `coverage_short` | revision covers fewer packages than the obligation's frozen `coverage.covered_package_ids` | **Yes.** |
+ * | `metric_missing` | a metric named in the pinned definition's `metrics[].name` is absent | **No.** `control_totals` are profile-defined aggregates scoped to `coverage.covered_package_ids`, a different and usually smaller set than the definition's metrics. |
+ * | `schema_nonconformant` | rows do not validate against the pinned `schema_uri`/`schema_sha256` | **No.** Requires actually validating rows. |
+ * | `currency_mismatch` | a value's unit disagrees with the unit the pinned definition fixed | **Yes.** |
+ * | `period_mismatch` | a row time dimension carries values outside the half-open period | **No.** The revision envelope is pinned stable by `slice_identity`; the violation lives in row values. |
+ */
+import type { ReportingControlTotal } from '../types/index.mjs';
+/** Closed set of reasons a consumed revision contradicts the accepted generation. */
+export type ReportingMismatchCodeV1 = 'scope_media_buy_missing' | 'coverage_short' | 'metric_missing' | 'schema_nonconformant' | 'currency_mismatch' | 'period_mismatch';
+/** Facts the accepted configuration generation froze, as the buyer recorded them. */
+export interface ReportingContractFactsV1 {
+    /** Frozen media-buy denominator from the obligation. */
+    mediaBuyIds?: readonly string[];
+    /** Frozen `coverage.covered_package_ids` from the obligation. */
+    coveredPackageIds?: readonly string[];
+    /** Half-open expected period. */
+    period?: {
+        start: string;
+        end: string;
+    };
+    /** `metrics[].name` from the pinned report definition. */
+    committedMetrics?: readonly string[];
+    /** Units the pinned report definition fixed, keyed by metric/control-total name. */
+    metricUnits?: Readonly<Record<string, string>>;
+}
+/** The exact revision the buyer read, as the seller published it. */
+export interface ReportingConsumedRevisionV1 {
+    reporting_revision_id?: string;
+    coverage?: {
+        status?: string;
+        covered_package_ids?: readonly string[];
+    };
+    control_totals?: readonly ReportingControlTotal[];
+}
+/**
+ * What the buyer's own reader observed in the revision's rows.
+ *
+ * Supply only what you actually determined. Every field is optional and each
+ * one gates exactly one code: omit it and that code cannot fire, which is the
+ * correct outcome for a buyer that did not look.
+ */
+export interface ReportingRowEvidenceV1 {
+    /**
+     * Media buys represented in the rows, counting a buy carried by an explicit
+     * zero row as represented — that zero row is precisely what lets the revision
+     * distinguish zero delivery from an omitted buy.
+     */
+    representedMediaBuyIds?: readonly string[];
+    /** Metric names actually present in the rows. */
+    observedMetricNames?: readonly string[];
+    /** `false` when the rows failed validation against the pinned profile schema. */
+    rowsConformToPinnedSchema?: boolean;
+    /** Range of the pinned grain's time dimension across the rows. */
+    observedPeriodBounds?: {
+        earliest: string;
+        latest: string;
+    };
+}
+export interface ReportingContentMismatchV1 {
+    mismatchCode: ReportingMismatchCodeV1;
+    /** Non-secret, bounded diagnostic naming the exact contradicted fact. */
+    detail: string;
+}
+/**
+ * First applicable contradiction between a consumed revision and the frozen
+ * contract, or `undefined` when nothing decidable is contradicted.
+ *
+ * **What `reconcileReporting` can reach, and what it cannot.** The reconciler
+ * consumes the revision's rows to recompute its binding digest, so it calls
+ * this with real row evidence — but it can only derive `observedMetricNames`,
+ * and only when the buyer pinned `committedMetrics`. That makes
+ * `coverage_short`, `currency_mismatch` and `metric_missing` reachable through
+ * the reconcile loop. The remaining three are a **documented limitation**:
+ *
+ * - `scope_media_buy_missing` needs to know which media buy a row belongs to.
+ * - `period_mismatch` needs the time dimension the pinned grain declares.
+ * - `schema_nonconformant` needs the rows validated against the pinned schema.
+ *
+ * All three depend on the reporting profile's own row shape, which is
+ * profile-defined and not readable from a generic row object. The SDK does not
+ * guess at them, because the cost of being wrong is asymmetric: a false
+ * `content_mismatch` pins the caller's view at `action_required` and the seller
+ * MUST NOT return the period to healthy while the statement is the current
+ * leaf. An adopter whose own reader *does* understand its profile can call this
+ * function directly with a fuller `ReportingRowEvidenceV1` and act on the
+ * result.
+ *
+ * **Precedence.** The spec pins exactly one ordering rule: a metric that is
+ * simply absent uses `metric_missing` even when the pinned schema declares it
+ * required, so `metric_missing` is evaluated before `schema_nonconformant`.
+ * The remaining order is this SDK's, chosen so the most structural fact wins —
+ * a revision missing a whole media buy reports that, not whichever metric
+ * happened to go missing with it — and is stable so the code does not flap
+ * between reads of the same bytes.
+ */
+export declare function detectReportingContentMismatch(facts: ReportingContractFactsV1, revision: ReportingConsumedRevisionV1, rows?: ReportingRowEvidenceV1): ReportingContentMismatchV1 | undefined;