niceeval 0.13.2 → 0.13.3

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

@@ -5,9 +5,12 @@ import type { Sha256Digest } from "../../record/model/identifiers.mjs";
 import type { AssertionResult, SealedAssertionEntry } from "../api.mjs";
 import { type ThirdPartyCriterionRegistry } from "./codec.mjs";
 import { type AssertionEntryInput, type AssertionsEntryIdSource, type AssertionsProducerError } from "./producer.mjs";
-import type { AssertionEntryId, AssertionCoverage as RecordAssertionCoverage, AssertionLimitation as RecordAssertionLimitation, AssertionsDocumentOuter, AssertionsProjection, BoundedJsonObject, BoundedJsonValue, SealedAssertionResult, WritableCriterionEnvelope } from "./model.mjs";
+import type { AssertionEntryId, AssertionFactValue, AssertionCoverage as RecordAssertionCoverage, AssertionLimitation as RecordAssertionLimitation, AssertionsDocumentOuter, AssertionsProjection, BoundedJsonObject, BoundedJsonValue, SealedAssertionResult, WritableCriterionEnvelope } from "./model.mjs";
 export declare const assertionsRecordSchemas: Readonly<{
     material: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["unavailable"]>;
+        reason: Schema.Literal<["not-recorded"]>;
+    }>, Schema.Struct<{
         kind: Schema.Literal<["snapshot"]>;
         value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
     }>, Schema.Struct<{
@@ -18,11 +21,107 @@ export declare const assertionsRecordSchemas: Readonly<{
         sha256: Schema.Schema<Sha256Digest, string, never>;
         preview: Schema.filter<typeof Schema.String>;
     }>]>;
-    entries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+    entries: Schema.filter<Schema.Array$<Schema.Struct<{
+        entryId: Schema.Schema<AssertionEntryId, string, never>;
+        display: Schema.Schema<import("./model.mjs").AssertionDisplay, import("./model.mjs").AssertionDisplay, never>;
+        criterion: Schema.Union<[Schema.Struct<{
+            state: Schema.Literal<["available"]>;
+            value: Schema.Schema<BoundedJsonObject, 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<BoundedJsonValue, 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<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<BoundedJsonValue, 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<Sha256Digest, string, never>;
+                preview: Schema.filter<typeof Schema.String>;
+            }>]>>;
+            coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
+            limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
+        }>>;
+        evaluation: Schema.Struct<{
+            observed: Schema.Schema<AssertionFactValue, 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("./model.mjs").NoScoreContribution, import("./model.mjs").NoScoreContribution, never>, Schema.Schema<import("./model.mjs").EarnedScoreContribution, import("./model.mjs").EarnedScoreContribution, never>, Schema.Schema<import("./model.mjs").UnavailableScoreContribution, import("./model.mjs").UnavailableScoreContribution, never>]>;
+        explanationRetention: Schema.Union<[Schema.Struct<{
+            state: Schema.Literal<["retained"]>;
+            value: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
+        }>, Schema.Struct<{
+            state: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>]>;
+    }>>>;
+    historicalEntries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
         entryId: Schema.Schema<AssertionEntryId, string, never>;
         display: Schema.Schema<import("./model.mjs").AssertionDisplay, import("./model.mjs").AssertionDisplay, never>;
         criterion: Schema.Schema<BoundedJsonObject, 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<BoundedJsonValue, BoundedJsonValue, never>;
         }>, Schema.Struct<{
@@ -34,6 +133,9 @@ export declare const assertionsRecordSchemas: Readonly<{
             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<BoundedJsonValue, BoundedJsonValue, never>;
         }>, Schema.Struct<{
@@ -49,73 +151,202 @@ export declare const assertionsRecordSchemas: Readonly<{
         result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
     }>>>>;
     outerDocument: Schema.filter<Schema.filter<Schema.Struct<{
-        entries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+        entries: Schema.filter<Schema.Array$<Schema.Struct<{
             entryId: Schema.Schema<AssertionEntryId, string, never>;
             display: Schema.Schema<import("./model.mjs").AssertionDisplay, import("./model.mjs").AssertionDisplay, never>;
-            criterion: Schema.Schema<BoundedJsonObject, BoundedJsonObject, never>;
-            subject: Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            criterion: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["available"]>;
+                value: Schema.Schema<BoundedJsonObject, BoundedJsonObject, 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<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
             }>]>;
-            evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            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<BoundedJsonValue, 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<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<BoundedJsonValue, 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<Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>>;
+                coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
+                limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
+            }>>;
+            evaluation: Schema.Struct<{
+                observed: Schema.Schema<AssertionFactValue, 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("./model.mjs").NoScoreContribution, import("./model.mjs").NoScoreContribution, never>, Schema.Schema<import("./model.mjs").EarnedScoreContribution, import("./model.mjs").EarnedScoreContribution, never>, Schema.Schema<import("./model.mjs").UnavailableScoreContribution, import("./model.mjs").UnavailableScoreContribution, never>]>;
+            explanationRetention: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["retained"]>;
+                value: Schema.Schema<AssertionFactValue, AssertionFactValue, 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<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
-            }>]>>;
-            coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
-            limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
-            result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
-        }>>>>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+        }>>>;
     }>>>;
     document: Schema.filter<Schema.filter<Schema.Struct<{
-        entries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+        entries: Schema.filter<Schema.Array$<Schema.Struct<{
             entryId: Schema.Schema<AssertionEntryId, string, never>;
             display: Schema.Schema<import("./model.mjs").AssertionDisplay, import("./model.mjs").AssertionDisplay, never>;
-            criterion: Schema.Schema<WritableCriterionEnvelope, WritableCriterionEnvelope, never>;
-            subject: Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            criterion: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["available"]>;
+                value: Schema.Schema<WritableCriterionEnvelope, WritableCriterionEnvelope, 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<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
             }>]>;
-            evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            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<BoundedJsonValue, 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<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<BoundedJsonValue, 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<Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>>;
+                coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
+                limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
+            }>>;
+            evaluation: Schema.Struct<{
+                observed: Schema.Schema<AssertionFactValue, 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("./model.mjs").NoScoreContribution, import("./model.mjs").NoScoreContribution, never>, Schema.Schema<import("./model.mjs").EarnedScoreContribution, import("./model.mjs").EarnedScoreContribution, never>, Schema.Schema<import("./model.mjs").UnavailableScoreContribution, import("./model.mjs").UnavailableScoreContribution, never>]>;
+            explanationRetention: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["retained"]>;
+                value: Schema.Schema<AssertionFactValue, AssertionFactValue, 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<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
-            }>]>>;
-            coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
-            limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
-            result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
-        }>>>>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+        }>>>;
     }>>>;
 }>;
 /** Complete payload-order projection required by Record's closure validator. */
 export declare function assertionBlobRefs(document: AssertionsDocumentOuter<RecordBlobRef>): readonly RecordBlobRef[];
 export type AssertionMaterialInput<E, R> = {
+    readonly kind: "unavailable";
+    readonly reason: "not-recorded";
+} | {
     readonly kind: "snapshot";
     readonly value: BoundedJsonValue;
 } | {
@@ -130,11 +361,17 @@ export type AssertionMaterialInput<E, R> = {
 export interface AssertionsAttachmentEntryInput<E, R> {
     readonly display: AssertionEntryInput<RecordBlobRef>["display"];
     readonly criterion: AssertionEntryInput<RecordBlobRef>["criterion"];
-    readonly subject: AssertionMaterialInput<E, R>;
-    readonly evidence: readonly AssertionMaterialInput<E, R>[];
-    readonly coverage: AssertionEntryInput<RecordBlobRef>["coverage"];
-    readonly limitations: AssertionEntryInput<RecordBlobRef>["limitations"];
-    readonly result: AssertionEntryInput<RecordBlobRef>["result"];
+    readonly materials: {
+        readonly source: AssertionMaterialInput<E, R>;
+        readonly evidence: readonly AssertionMaterialInput<E, R>[];
+        readonly coverage: AssertionEntryInput<RecordBlobRef>["materials"]["coverage"];
+        readonly limitations: AssertionEntryInput<RecordBlobRef>["materials"]["limitations"];
+    };
+    readonly evaluation: AssertionEntryInput<RecordBlobRef>["evaluation"];
+    readonly decision: AssertionEntryInput<RecordBlobRef>["decision"];
+    readonly policy: AssertionEntryInput<RecordBlobRef>["policy"];
+    readonly contribution: AssertionEntryInput<RecordBlobRef>["contribution"];
+    readonly explanationRetention: AssertionEntryInput<RecordBlobRef>["explanationRetention"];
 }
 export declare function encodeAssertionResult(result: AssertionResult): SealedAssertionResult;
 /** Private Runtime → durable Assertions codec bridge. */