niceeval 0.13.2 → 0.13.3

package/dist/record/family/assertions.d.mts

@@ -23,11 +23,107 @@ export declare const AssertionSourceSiteSchema: Schema.Struct<{
 }>;
 export type AssertionSourceSite = Schema.Schema.Type<typeof AssertionSourceSiteSchema>;
 /** Reuse the existing v1 entry schema inside the one direct attachment schema. */
-export declare const AssertionsEntriesSchema: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+export declare const AssertionsEntriesSchema: Schema.filter<Schema.Array$<Schema.Struct<{
+    entryId: Schema.Schema<import("../../index.mjs").AssertionEntryId, string, never>;
+    display: Schema.Schema<import("../../assertions/record/model.mjs").AssertionDisplay, import("../../assertions/record/model.mjs").AssertionDisplay, never>;
+    criterion: Schema.Union<[Schema.Struct<{
+        state: Schema.Literal<["available"]>;
+        value: Schema.Schema<import("../../assertions/record/model.mjs").BoundedJsonObject, import("../../assertions/record/model.mjs").BoundedJsonObject, never>;
+    }>, Schema.Struct<{
+        state: Schema.Literal<["unavailable"]>;
+        reason: Schema.Literal<["not-recorded"]>;
+    }>]>;
+    materials: Schema.filter<Schema.Struct<{
+        source: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["snapshot"]>;
+            value: Schema.Schema<import("../../assertions/record/model.mjs").BoundedJsonValue, import("../../assertions/record/model.mjs").BoundedJsonValue, never>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["blob"]>;
+            ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+            encoding: Schema.Literal<["utf-8", "binary"]>;
+            byteLength: Schema.filter<typeof Schema.JsonNumber>;
+            sha256: Schema.Schema<import("../model/identifiers.mjs").Sha256Digest, string, never>;
+            preview: Schema.filter<typeof Schema.String>;
+        }>]>;
+        evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["snapshot"]>;
+            value: Schema.Schema<import("../../assertions/record/model.mjs").BoundedJsonValue, import("../../assertions/record/model.mjs").BoundedJsonValue, never>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["blob"]>;
+            ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+            encoding: Schema.Literal<["utf-8", "binary"]>;
+            byteLength: Schema.filter<typeof Schema.JsonNumber>;
+            sha256: Schema.Schema<import("../model/identifiers.mjs").Sha256Digest, string, never>;
+            preview: Schema.filter<typeof Schema.String>;
+        }>]>>;
+        coverage: Schema.Schema<import("../../assertions/record/model.mjs").AssertionCoverage, import("../../assertions/record/model.mjs").AssertionCoverage, never>;
+        limitations: Schema.Array$<Schema.Schema<import("../../assertions/record/model.mjs").AssertionLimitation, import("../../assertions/record/model.mjs").AssertionLimitation, never>>;
+    }>>;
+    evaluation: Schema.Struct<{
+        observed: Schema.Schema<import("../../assertions/record/model.mjs").AssertionFactValue, import("../../assertions/record/model.mjs").AssertionFactValue, never>;
+        receipt: Schema.optional<Schema.Struct<{
+            examined: Schema.filter<typeof Schema.JsonNumber>;
+            matched: Schema.filter<typeof Schema.JsonNumber>;
+            mismatched: Schema.filter<typeof Schema.JsonNumber>;
+            unavailable: Schema.filter<typeof Schema.JsonNumber>;
+            knownTotal: Schema.NullOr<Schema.filter<typeof Schema.JsonNumber>>;
+            complete: typeof Schema.Boolean;
+            exhaustive: typeof Schema.Boolean;
+            decisive: typeof Schema.Boolean;
+        }>>;
+    }>;
+    decision: Schema.Struct<{
+        result: Schema.Literal<["matched", "mismatched", "unavailable", "errored", "not-applicable"]>;
+        reason: Schema.NullOr<Schema.Literal<["condition-not-met", "evidence-unavailable", "source-unavailable", "redacted", "evaluator-failed", "producer-interrupted", "invalid-subject", "coverage-not-applicable"]>>;
+        gate: Schema.Literal<["not-gate", "satisfied", "failed", "unavailable", "not-applicable"]>;
+    }>;
+    policy: Schema.Struct<{
+        requirement: Schema.Union<[Schema.Struct<{
+            state: Schema.Literal<["available"]>;
+            value: Schema.Literal<["required", "optional"]>;
+        }>, Schema.Struct<{
+            state: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>]>;
+        condition: Schema.Union<[Schema.Struct<{
+            state: Schema.Literal<["available"]>;
+            value: Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["boolean"]>;
+                expected: Schema.Literal<[true]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["at-least"]>;
+                threshold: Schema.filter<typeof Schema.JsonNumber>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["record-only"]>;
+            }>]>;
+        }>, Schema.Struct<{
+            state: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>]>;
+    }>;
+    contribution: Schema.Union<[Schema.Schema<import("../../assertions/record/model.mjs").NoScoreContribution, import("../../assertions/record/model.mjs").NoScoreContribution, never>, Schema.Schema<import("../../assertions/record/model.mjs").EarnedScoreContribution, import("../../assertions/record/model.mjs").EarnedScoreContribution, never>, Schema.Schema<import("../../assertions/record/model.mjs").UnavailableScoreContribution, import("../../assertions/record/model.mjs").UnavailableScoreContribution, never>]>;
+    explanationRetention: Schema.Union<[Schema.Struct<{
+        state: Schema.Literal<["retained"]>;
+        value: Schema.Schema<import("../../assertions/record/model.mjs").AssertionFactValue, import("../../assertions/record/model.mjs").AssertionFactValue, never>;
+    }>, Schema.Struct<{
+        state: Schema.Literal<["unavailable"]>;
+        reason: Schema.Literal<["not-recorded"]>;
+    }>]>;
+}>>>;
+export declare const AssertionsEntriesV1Schema: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
     entryId: Schema.Schema<import("../../index.mjs").AssertionEntryId, string, never>;
     display: Schema.Schema<import("../../assertions/record/model.mjs").AssertionDisplay, import("../../assertions/record/model.mjs").AssertionDisplay, never>;
     criterion: Schema.Schema<import("../../assertions/record/model.mjs").BoundedJsonObject, import("../../assertions/record/model.mjs").BoundedJsonObject, never>;
     subject: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["unavailable"]>;
+        reason: Schema.Literal<["not-recorded"]>;
+    }>, Schema.Struct<{
         kind: Schema.Literal<["snapshot"]>;
         value: Schema.Schema<import("../../assertions/record/model.mjs").BoundedJsonValue, import("../../assertions/record/model.mjs").BoundedJsonValue, never>;
     }>, Schema.Struct<{
@@ -39,6 +135,9 @@ export declare const AssertionsEntriesSchema: Schema.filter<Schema.Array$<Schema
         preview: Schema.filter<typeof Schema.String>;
     }>]>;
     evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["unavailable"]>;
+        reason: Schema.Literal<["not-recorded"]>;
+    }>, Schema.Struct<{
         kind: Schema.Literal<["snapshot"]>;
         value: Schema.Schema<import("../../assertions/record/model.mjs").BoundedJsonValue, import("../../assertions/record/model.mjs").BoundedJsonValue, never>;
     }>, Schema.Struct<{
@@ -74,11 +173,231 @@ export declare const AssertionSourceSitesSchema: Schema.Array$<Schema.Struct<{
  */
 /** One direct current schema: Type fields and durable keys share all v1 filters. */
 export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Schema.filter<Schema.filter<Schema.Struct<{
+    entries: Schema.PropertySignature<":", readonly {
+        readonly evaluation: {
+            readonly receipt?: {
+                readonly complete: boolean;
+                readonly unavailable: number;
+                readonly matched: number;
+                readonly mismatched: number;
+                readonly knownTotal: number | null;
+                readonly examined: number;
+                readonly exhaustive: boolean;
+                readonly decisive: boolean;
+            } | undefined;
+            readonly observed: import("../../assertions/record/model.mjs").AssertionFactValue;
+        };
+        readonly display: import("../../assertions/record/model.mjs").AssertionDisplay;
+        readonly criterion: {
+            readonly value: import("../../assertions/record/model.mjs").BoundedJsonObject;
+            readonly state: "available";
+        } | {
+            readonly reason: "not-recorded";
+            readonly state: "unavailable";
+        };
+        readonly policy: {
+            readonly condition: {
+                readonly value: {
+                    readonly expected: true;
+                    readonly kind: "boolean";
+                } | {
+                    readonly kind: "at-least";
+                    readonly threshold: number;
+                } | {
+                    readonly kind: "record-only";
+                };
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly requirement: {
+                readonly value: "optional" | "required";
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+        };
+        readonly decision: {
+            readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+            readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+            readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+        };
+        readonly contribution: import("../../assertions/record/model.mjs").NoScoreContribution | import("../../assertions/record/model.mjs").EarnedScoreContribution | import("../../assertions/record/model.mjs").UnavailableScoreContribution;
+        readonly entryId: import("../../index.mjs").AssertionEntryId;
+        readonly materials: {
+            readonly source: {
+                readonly reason: "not-recorded";
+                readonly kind: "unavailable";
+            } | {
+                readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                readonly kind: "snapshot";
+            } | {
+                readonly kind: "blob";
+                readonly ref: RecordBlobRef;
+                readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
+                readonly encoding: "utf-8" | "binary";
+                readonly preview: string;
+                readonly byteLength: number;
+            };
+            readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
+            readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
+            readonly evidence: readonly ({
+                readonly reason: "not-recorded";
+                readonly kind: "unavailable";
+            } | {
+                readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                readonly kind: "snapshot";
+            } | {
+                readonly kind: "blob";
+                readonly ref: RecordBlobRef;
+                readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
+                readonly encoding: "utf-8" | "binary";
+                readonly preview: string;
+                readonly byteLength: number;
+            })[];
+        };
+        readonly explanationRetention: {
+            readonly value: import("../../assertions/record/model.mjs").AssertionFactValue;
+            readonly state: "retained";
+        } | {
+            readonly reason: "not-recorded";
+            readonly state: "unavailable";
+        };
+    }[], "entries-data", ":", readonly {
+        readonly evaluation: {
+            readonly observed: import("../../assertions/record/model.mjs").AssertionFactValue;
+            readonly receipt?: {
+                readonly complete: boolean;
+                readonly unavailable: number;
+                readonly matched: number;
+                readonly mismatched: number;
+                readonly knownTotal: number | null;
+                readonly examined: number;
+                readonly exhaustive: boolean;
+                readonly decisive: boolean;
+            } | undefined;
+        };
+        readonly display: import("../../assertions/record/model.mjs").AssertionDisplay;
+        readonly criterion: {
+            readonly value: import("../../assertions/record/model.mjs").BoundedJsonObject;
+            readonly state: "available";
+        } | {
+            readonly reason: "not-recorded";
+            readonly state: "unavailable";
+        };
+        readonly policy: {
+            readonly condition: {
+                readonly value: {
+                    readonly expected: true;
+                    readonly kind: "boolean";
+                } | {
+                    readonly kind: "at-least";
+                    readonly threshold: number;
+                } | {
+                    readonly kind: "record-only";
+                };
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly requirement: {
+                readonly value: "optional" | "required";
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+        };
+        readonly decision: {
+            readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+            readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+            readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+        };
+        readonly contribution: import("../../assertions/record/model.mjs").NoScoreContribution | import("../../assertions/record/model.mjs").EarnedScoreContribution | import("../../assertions/record/model.mjs").UnavailableScoreContribution;
+        readonly entryId: string;
+        readonly materials: {
+            readonly source: {
+                readonly reason: "not-recorded";
+                readonly kind: "unavailable";
+            } | {
+                readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                readonly kind: "snapshot";
+            } | {
+                readonly kind: "blob";
+                readonly ref: RecordBlobRef;
+                readonly sha256: string;
+                readonly encoding: "utf-8" | "binary";
+                readonly preview: string;
+                readonly byteLength: number;
+            };
+            readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
+            readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
+            readonly evidence: readonly ({
+                readonly reason: "not-recorded";
+                readonly kind: "unavailable";
+            } | {
+                readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                readonly kind: "snapshot";
+            } | {
+                readonly kind: "blob";
+                readonly ref: RecordBlobRef;
+                readonly sha256: string;
+                readonly encoding: "utf-8" | "binary";
+                readonly preview: string;
+                readonly byteLength: number;
+            })[];
+        };
+        readonly explanationRetention: {
+            readonly value: import("../../assertions/record/model.mjs").AssertionFactValue;
+            readonly state: "retained";
+        } | {
+            readonly reason: "not-recorded";
+            readonly state: "unavailable";
+        };
+    }[], false, never>;
+    sourceSites: Schema.PropertySignature<":", readonly {
+        readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+        readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
+        readonly start: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly end: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly entryId: import("../../index.mjs").AssertionEntryId;
+        readonly sourceItemId: import("../model/identifiers.mjs").SourceItemId;
+        readonly sourceOrder: number;
+    }[], "source-sites-data", ":", readonly {
+        readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+        readonly sha256: string;
+        readonly start: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly end: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly entryId: string;
+        readonly sourceItemId: string;
+        readonly sourceOrder: number;
+    }[], false, never>;
+}>>>>>;
+/** @internal Package-private historical wire codec, loaded only by maintenance. */
+export declare const AssertionsAttachmentV1Schema: Schema.Struct<{
     entries: Schema.PropertySignature<":", readonly {
         readonly result: import("../../assertions/record/model.mjs").SealedAssertionResult;
         readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
         readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
         readonly subject: {
+            readonly reason: "not-recorded";
+            readonly kind: "unavailable";
+        } | {
             readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
             readonly kind: "snapshot";
         } | {
@@ -90,6 +409,9 @@ export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Sch
             readonly byteLength: number;
         };
         readonly evidence: readonly ({
+            readonly reason: "not-recorded";
+            readonly kind: "unavailable";
+        } | {
             readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
             readonly kind: "snapshot";
         } | {
@@ -108,6 +430,9 @@ export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Sch
         readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
         readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
         readonly subject: {
+            readonly reason: "not-recorded";
+            readonly kind: "unavailable";
+        } | {
             readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
             readonly kind: "snapshot";
         } | {
@@ -119,6 +444,9 @@ export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Sch
             readonly byteLength: number;
         };
         readonly evidence: readonly ({
+            readonly reason: "not-recorded";
+            readonly kind: "unavailable";
+        } | {
             readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
             readonly kind: "snapshot";
         } | {
@@ -144,9 +472,9 @@ export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Sch
             readonly line: number;
             readonly column: number;
         };
+        readonly entryId: import("../../index.mjs").AssertionEntryId;
         readonly sourceItemId: import("../model/identifiers.mjs").SourceItemId;
         readonly sourceOrder: number;
-        readonly entryId: import("../../index.mjs").AssertionEntryId;
     }[], "source-sites-data", ":", readonly {
         readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
         readonly sha256: string;
@@ -158,11 +486,11 @@ export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Sch
             readonly line: number;
             readonly column: number;
         };
+        readonly entryId: string;
         readonly sourceItemId: string;
         readonly sourceOrder: number;
-        readonly entryId: string;
     }[], false, never>;
-}>>>>>;
+}>;
 export type AssertionsAttachment = Schema.Schema.Type<typeof AssertionsAttachmentSchema>;
 /** Complete closure projection for `niceeval.assertions`. */
 export declare function assertionsBlobRefs(payload: AssertionsAttachment): readonly RecordBlobRef[];
@@ -182,63 +510,189 @@ export declare const assertionsRecordAttachment: import("../definition/attachmen
     readonly attempt: {
         readonly schema: Schema.filter<Schema.filter<Schema.filter<Schema.filter<Schema.Struct<{
             entries: Schema.PropertySignature<":", readonly {
-                readonly result: import("../../assertions/record/model.mjs").SealedAssertionResult;
-                readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
-                readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
-                readonly subject: {
-                    readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
+                readonly evaluation: {
+                    readonly receipt?: {
+                        readonly complete: boolean;
+                        readonly unavailable: number;
+                        readonly matched: number;
+                        readonly mismatched: number;
+                        readonly knownTotal: number | null;
+                        readonly examined: number;
+                        readonly exhaustive: boolean;
+                        readonly decisive: boolean;
+                    } | undefined;
+                    readonly observed: import("../../assertions/record/model.mjs").AssertionFactValue;
                 };
-                readonly evidence: readonly ({
-                    readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
-                })[];
                 readonly display: import("../../assertions/record/model.mjs").AssertionDisplay;
-                readonly criterion: import("../../assertions/record/model.mjs").BoundedJsonObject;
-                readonly entryId: import("../../index.mjs").AssertionEntryId;
-            }[], "entries-data", ":", readonly {
-                readonly result: import("../../assertions/record/model.mjs").SealedAssertionResult;
-                readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
-                readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
-                readonly subject: {
-                    readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
-                    readonly kind: "snapshot";
+                readonly criterion: {
+                    readonly value: import("../../assertions/record/model.mjs").BoundedJsonObject;
+                    readonly state: "available";
                 } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: string;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly policy: {
+                    readonly condition: {
+                        readonly value: {
+                            readonly expected: true;
+                            readonly kind: "boolean";
+                        } | {
+                            readonly kind: "at-least";
+                            readonly threshold: number;
+                        } | {
+                            readonly kind: "record-only";
+                        };
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly requirement: {
+                        readonly value: "optional" | "required";
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                };
+                readonly decision: {
+                    readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                    readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                    readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
                 };
-                readonly evidence: readonly ({
-                    readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
-                    readonly kind: "snapshot";
+                readonly contribution: import("../../assertions/record/model.mjs").NoScoreContribution | import("../../assertions/record/model.mjs").EarnedScoreContribution | import("../../assertions/record/model.mjs").UnavailableScoreContribution;
+                readonly entryId: import("../../index.mjs").AssertionEntryId;
+                readonly materials: {
+                    readonly source: {
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    };
+                    readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
+                    readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
+                    readonly evidence: readonly ({
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../model/identifiers.mjs").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    })[];
+                };
+                readonly explanationRetention: {
+                    readonly value: import("../../assertions/record/model.mjs").AssertionFactValue;
+                    readonly state: "retained";
                 } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: string;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
-                })[];
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+            }[], "entries-data", ":", readonly {
+                readonly evaluation: {
+                    readonly observed: import("../../assertions/record/model.mjs").AssertionFactValue;
+                    readonly receipt?: {
+                        readonly complete: boolean;
+                        readonly unavailable: number;
+                        readonly matched: number;
+                        readonly mismatched: number;
+                        readonly knownTotal: number | null;
+                        readonly examined: number;
+                        readonly exhaustive: boolean;
+                        readonly decisive: boolean;
+                    } | undefined;
+                };
                 readonly display: import("../../assertions/record/model.mjs").AssertionDisplay;
-                readonly criterion: import("../../assertions/record/model.mjs").BoundedJsonObject;
+                readonly criterion: {
+                    readonly value: import("../../assertions/record/model.mjs").BoundedJsonObject;
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly policy: {
+                    readonly condition: {
+                        readonly value: {
+                            readonly expected: true;
+                            readonly kind: "boolean";
+                        } | {
+                            readonly kind: "at-least";
+                            readonly threshold: number;
+                        } | {
+                            readonly kind: "record-only";
+                        };
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly requirement: {
+                        readonly value: "optional" | "required";
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                };
+                readonly decision: {
+                    readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                    readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                    readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                };
+                readonly contribution: import("../../assertions/record/model.mjs").NoScoreContribution | import("../../assertions/record/model.mjs").EarnedScoreContribution | import("../../assertions/record/model.mjs").UnavailableScoreContribution;
                 readonly entryId: string;
+                readonly materials: {
+                    readonly source: {
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: string;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    };
+                    readonly coverage: import("../../assertions/record/model.mjs").AssertionCoverage;
+                    readonly limitations: readonly import("../../assertions/record/model.mjs").AssertionLimitation[];
+                    readonly evidence: readonly ({
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../../assertions/record/model.mjs").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: string;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    })[];
+                };
+                readonly explanationRetention: {
+                    readonly value: import("../../assertions/record/model.mjs").AssertionFactValue;
+                    readonly state: "retained";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
             }[], false, never>;
             sourceSites: Schema.PropertySignature<":", readonly {
                 readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -251,9 +705,9 @@ export declare const assertionsRecordAttachment: import("../definition/attachmen
                     readonly line: number;
                     readonly column: number;
                 };
+                readonly entryId: import("../../index.mjs").AssertionEntryId;
                 readonly sourceItemId: import("../model/identifiers.mjs").SourceItemId;
                 readonly sourceOrder: number;
-                readonly entryId: import("../../index.mjs").AssertionEntryId;
             }[], "source-sites-data", ":", readonly {
                 readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
                 readonly sha256: string;
@@ -265,9 +719,9 @@ export declare const assertionsRecordAttachment: import("../definition/attachmen
                     readonly line: number;
                     readonly column: number;
                 };
+                readonly entryId: string;
                 readonly sourceItemId: string;
                 readonly sourceOrder: number;
-                readonly entryId: string;
             }[], false, never>;
         }>>>>>;
         readonly limits: Readonly<{