@trylimbo/sdk-verifier 0.2.11-canary.18 → 0.2.11

package/gen/ffi/index.js

@@ -2272,7 +2272,7 @@ var trylimbo_verifier_exports = /* @__PURE__ */ __exportAll({
 	RecoveryDiscovery: () => RecoveryDiscovery,
 	RecoveryDiscovery_Tags: () => RecoveryDiscovery_Tags,
 	RecoveryIssue: () => RecoveryIssue,
-	RecoveryIssueKind: () => RecoveryIssueKind,
+	RecoveryIssue_Tags: () => RecoveryIssue_Tags,
 	RecoveryPolicy: () => RecoveryPolicy,
 	RecoveryStatus: () => RecoveryStatus,
 	RecoverySummary: () => RecoverySummary,
@@ -2311,6 +2311,9 @@ var trylimbo_verifier_exports = /* @__PURE__ */ __exportAll({
 	ValidationResults: () => ValidationResults,
 	ValidationState: () => ValidationState,
 	ValidationStatus: () => ValidationStatus,
+	Verdict: () => Verdict,
+	VerdictRule: () => VerdictRule,
+	Verdict_Tags: () => Verdict_Tags,
 	VerifyOptions: () => VerifyOptions,
 	c2paTrustList: () => c2paTrustList,
 	c2paTsaTrustList: () => c2paTsaTrustList,
@@ -4716,93 +4719,522 @@ const FfiConverterTypeRecoveryStatus = (() => {
 	}
 	return new FFIConverter();
 })();
+let RecoveryIssue_Tags = /* @__PURE__ */ function(RecoveryIssue_Tags) {
+	RecoveryIssue_Tags["Binder"] = "Binder";
+	RecoveryIssue_Tags["DeprecatedAlgorithm"] = "DeprecatedAlgorithm";
+	RecoveryIssue_Tags["BindingQuery"] = "BindingQuery";
+	RecoveryIssue_Tags["QueryRefused"] = "QueryRefused";
+	RecoveryIssue_Tags["ContentForm"] = "ContentForm";
+	RecoveryIssue_Tags["ContentQuery"] = "ContentQuery";
+	RecoveryIssue_Tags["Capabilities"] = "Capabilities";
+	RecoveryIssue_Tags["ContentTooLarge"] = "ContentTooLarge";
+	RecoveryIssue_Tags["CandidateFetch"] = "CandidateFetch";
+	RecoveryIssue_Tags["CandidateValidation"] = "CandidateValidation";
+	RecoveryIssue_Tags["EndpointRefused"] = "EndpointRefused";
+	RecoveryIssue_Tags["ResourceLimit"] = "ResourceLimit";
+	return RecoveryIssue_Tags;
+}({});
 /**
 * Why registry recovery did not complete cleanly, or why one candidate was omitted while another
-* succeeded. Kept as data so a partial recovery never loses the rest of the lookup outcome.
+* succeeded. Kept as data so a partial recovery never loses the rest of the lookup outcome, and
+* each kind carries exactly what it is about.
 */
-let RecoveryIssueKind = /* @__PURE__ */ function(RecoveryIssueKind) {
-	RecoveryIssueKind[RecoveryIssueKind["Binder"] = 0] = "Binder";
-	RecoveryIssueKind[RecoveryIssueKind["BindingQuery"] = 1] = "BindingQuery";
-	RecoveryIssueKind[RecoveryIssueKind["QueryRefused"] = 2] = "QueryRefused";
-	RecoveryIssueKind[RecoveryIssueKind["ContentQuery"] = 3] = "ContentQuery";
-	RecoveryIssueKind[RecoveryIssueKind["Capabilities"] = 4] = "Capabilities";
-	RecoveryIssueKind[RecoveryIssueKind["ContentTooLarge"] = 5] = "ContentTooLarge";
-	RecoveryIssueKind[RecoveryIssueKind["CandidateFetch"] = 6] = "CandidateFetch";
-	RecoveryIssueKind[RecoveryIssueKind["CandidateValidation"] = 7] = "CandidateValidation";
-	RecoveryIssueKind[RecoveryIssueKind["ResourceLimit"] = 8] = "ResourceLimit";
+const RecoveryIssue = (() => {
+	/**
+	* A binder faulted while deriving its binding.
+	*/
+	class Binder_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "Binder";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "Binder");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Binder_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Binder";
+		}
+	}
+	/**
+	* A binding or an advertised detector names an algorithm the C2PA list deprecates, which a
+	* validator should not resolve (2.4 18.10.4).
+	*/
+	class DeprecatedAlgorithm_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "DeprecatedAlgorithm";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "DeprecatedAlgorithm");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new DeprecatedAlgorithm_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "DeprecatedAlgorithm";
+		}
+	}
+	/**
+	* A binder's `matches/byBinding` lookup failed upstream.
+	*/
+	class BindingQuery_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "BindingQuery";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "BindingQuery");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new BindingQuery_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "BindingQuery";
+		}
+	}
+	/**
+	* The registry refused a query under this algorithm: a lookup it answered 4xx, or a named
+	* detector it does not advertise.
+	*/
+	class QueryRefused_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "QueryRefused";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "QueryRefused");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new QueryRefused_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "QueryRefused";
+		}
+	}
+	/**
+	* A content form could not be asked at all.
+	*/
+	class ContentForm_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "ContentForm";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "ContentForm");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new ContentForm_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "ContentForm";
+		}
+	}
+	/**
+	* One content request, under this algorithm, failed upstream.
+	*/
+	class ContentQuery_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "ContentQuery";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "ContentQuery");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new ContentQuery_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "ContentQuery";
+		}
+	}
+	/**
+	* The registry's capabilities could not be read.
+	*/
+	class Capabilities_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "Capabilities";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "Capabilities");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Capabilities_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Capabilities";
+		}
+	}
+	/**
+	* The asset is above the `byContent` upload cap, so the content form did not run.
+	*/
+	class ContentTooLarge_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "ContentTooLarge";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "ContentTooLarge");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new ContentTooLarge_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "ContentTooLarge";
+		}
+	}
+	/**
+	* A matched manifest could not be fetched.
+	*/
+	class CandidateFetch_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "CandidateFetch";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "CandidateFetch");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new CandidateFetch_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "CandidateFetch";
+		}
+	}
+	/**
+	* A fetched manifest did not validate as a credential for this asset.
+	*/
+	class CandidateValidation_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "CandidateValidation";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "CandidateValidation");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new CandidateValidation_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "CandidateValidation";
+		}
+	}
 	/**
 	* A match named a resolution API this verifier was not configured to fetch from.
 	*/
-	RecoveryIssueKind[RecoveryIssueKind["EndpointRefused"] = 9] = "EndpointRefused";
-	return RecoveryIssueKind;
-}({});
-const FfiConverterTypeRecoveryIssueKind = (() => {
-	class FFIConverter extends AbstractFfiConverterByteArray {
-		readFromCursor(c) {
-			switch (c.readI32()) {
-				case 1: return 0;
-				case 2: return 1;
-				case 3: return 2;
-				case 4: return 3;
-				case 5: return 4;
-				case 6: return 5;
-				case 7: return 6;
-				case 8: return 7;
-				case 9: return 8;
-				case 10: return 9;
-				default: throw new UniffiInternalError.UnexpectedEnumCase();
-			}
+	class EndpointRefused_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "EndpointRefused";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "EndpointRefused");
+			this.inner = Object.freeze(inner);
 		}
-		writeIntoCursor(value, c) {
-			switch (value) {
-				case 0: return c.writeI32(1);
-				case 1: return c.writeI32(2);
-				case 2: return c.writeI32(3);
-				case 3: return c.writeI32(4);
-				case 4: return c.writeI32(5);
-				case 5: return c.writeI32(6);
-				case 6: return c.writeI32(7);
-				case 7: return c.writeI32(8);
-				case 8: return c.writeI32(9);
-				case 9: return c.writeI32(10);
-			}
+		static new(inner) {
+			return new EndpointRefused_(inner);
 		}
-		allocationSize(value) {
-			return 4;
+		static instanceOf(obj) {
+			return obj.tag === "EndpointRefused";
 		}
 	}
-	return new FFIConverter();
-})();
-/**
-* Generated factory for {@link RecoveryIssue} record objects.
-*/
-const RecoveryIssue = (() => {
-	const defaults = () => ({ manifestId: void 0 });
-	const create = (() => {
-		return uniffiCreateRecord(defaults);
-	})();
+	/**
+	* A cumulative byte or time budget ended the batch before every candidate was processed.
+	*/
+	class ResourceLimit_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "RecoveryIssue";
+		tag = "ResourceLimit";
+		inner;
+		constructor(inner) {
+			super("RecoveryIssue", "ResourceLimit");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new ResourceLimit_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "ResourceLimit";
+		}
+	}
+	function instanceOf(obj) {
+		return obj[uniffiTypeNameSymbol] === "RecoveryIssue";
+	}
 	return Object.freeze({
-		create,
-		new: create,
-		defaults: () => Object.freeze(defaults())
+		instanceOf,
+		Binder: Binder_,
+		DeprecatedAlgorithm: DeprecatedAlgorithm_,
+		BindingQuery: BindingQuery_,
+		QueryRefused: QueryRefused_,
+		ContentForm: ContentForm_,
+		ContentQuery: ContentQuery_,
+		Capabilities: Capabilities_,
+		ContentTooLarge: ContentTooLarge_,
+		CandidateFetch: CandidateFetch_,
+		CandidateValidation: CandidateValidation_,
+		EndpointRefused: EndpointRefused_,
+		ResourceLimit: ResourceLimit_
 	});
 })();
 const FfiConverterTypeRecoveryIssue = (() => {
 	class FFIConverter extends AbstractFfiConverterByteArray {
 		readFromCursor(c) {
-			return {
-				kind: FfiConverterTypeRecoveryIssueKind.readFromCursor(c),
-				manifestId: FfiConverterOptionalString.readFromCursor(c),
-				message: FfiConverterString.readFromCursor(c)
-			};
+			switch (c.readI32()) {
+				case 1: return new RecoveryIssue.Binder({
+					binderIndex: FfiConverterUInt32.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c)
+				});
+				case 2: return new RecoveryIssue.DeprecatedAlgorithm({ algorithm: FfiConverterString.readFromCursor(c) });
+				case 3: return new RecoveryIssue.BindingQuery({
+					binderIndex: FfiConverterUInt32.readFromCursor(c),
+					algorithm: FfiConverterString.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c)
+				});
+				case 4: return new RecoveryIssue.QueryRefused({
+					algorithm: FfiConverterString.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c)
+				});
+				case 5: return new RecoveryIssue.ContentForm({ message: FfiConverterString.readFromCursor(c) });
+				case 6: return new RecoveryIssue.ContentQuery({
+					algorithm: FfiConverterString.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c)
+				});
+				case 7: return new RecoveryIssue.Capabilities({ message: FfiConverterString.readFromCursor(c) });
+				case 8: return new RecoveryIssue.ContentTooLarge({ capBytes: FfiConverterUInt64.readFromCursor(c) });
+				case 9: return new RecoveryIssue.CandidateFetch({
+					manifestId: FfiConverterString.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c)
+				});
+				case 10: return new RecoveryIssue.CandidateValidation({
+					manifestId: FfiConverterString.readFromCursor(c),
+					reason: FfiConverterString.readFromCursor(c)
+				});
+				case 11: return new RecoveryIssue.EndpointRefused({
+					manifestId: FfiConverterString.readFromCursor(c),
+					endpoint: FfiConverterString.readFromCursor(c)
+				});
+				case 12: return new RecoveryIssue.ResourceLimit({ message: FfiConverterString.readFromCursor(c) });
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
 		}
 		writeIntoCursor(value, c) {
-			FfiConverterTypeRecoveryIssueKind.writeIntoCursor(value.kind, c);
-			FfiConverterOptionalString.writeIntoCursor(value.manifestId, c);
-			FfiConverterString.writeIntoCursor(value.message, c);
+			switch (value.tag) {
+				case "Binder": {
+					c.writeI32(1);
+					const inner = value.inner;
+					FfiConverterUInt32.writeIntoCursor(inner.binderIndex, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "DeprecatedAlgorithm": {
+					c.writeI32(2);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.algorithm, c);
+					return;
+				}
+				case "BindingQuery": {
+					c.writeI32(3);
+					const inner = value.inner;
+					FfiConverterUInt32.writeIntoCursor(inner.binderIndex, c);
+					FfiConverterString.writeIntoCursor(inner.algorithm, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "QueryRefused": {
+					c.writeI32(4);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.algorithm, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "ContentForm": {
+					c.writeI32(5);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "ContentQuery": {
+					c.writeI32(6);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.algorithm, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "Capabilities": {
+					c.writeI32(7);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "ContentTooLarge": {
+					c.writeI32(8);
+					const inner = value.inner;
+					FfiConverterUInt64.writeIntoCursor(inner.capBytes, c);
+					return;
+				}
+				case "CandidateFetch": {
+					c.writeI32(9);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.manifestId, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				case "CandidateValidation": {
+					c.writeI32(10);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.manifestId, c);
+					FfiConverterString.writeIntoCursor(inner.reason, c);
+					return;
+				}
+				case "EndpointRefused": {
+					c.writeI32(11);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.manifestId, c);
+					FfiConverterString.writeIntoCursor(inner.endpoint, c);
+					return;
+				}
+				case "ResourceLimit": {
+					c.writeI32(12);
+					const inner = value.inner;
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
 		}
 		allocationSize(value) {
-			return FfiConverterTypeRecoveryIssueKind.allocationSize(value.kind) + FfiConverterOptionalString.allocationSize(value.manifestId) + FfiConverterString.allocationSize(value.message);
+			switch (value.tag) {
+				case "Binder": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterUInt32.allocationSize(inner.binderIndex);
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "DeprecatedAlgorithm": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.algorithm);
+					return size;
+				}
+				case "BindingQuery": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterUInt32.allocationSize(inner.binderIndex);
+					size += FfiConverterString.allocationSize(inner.algorithm);
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "QueryRefused": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.algorithm);
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "ContentForm": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "ContentQuery": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.algorithm);
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "Capabilities": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "ContentTooLarge": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterUInt64.allocationSize(inner.capBytes);
+					return size;
+				}
+				case "CandidateFetch": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.manifestId);
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				case "CandidateValidation": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.manifestId);
+					size += FfiConverterString.allocationSize(inner.reason);
+					return size;
+				}
+				case "EndpointRefused": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.manifestId);
+					size += FfiConverterString.allocationSize(inner.endpoint);
+					return size;
+				}
+				case "ResourceLimit": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
 		}
 	}
 	return new FFIConverter();
@@ -4811,7 +5243,7 @@ const FfiConverterTypeRecoveryIssue = (() => {
 * Generated factory for {@link RecoverySummary} record objects.
 */
 const RecoverySummary = (() => {
-	const defaults = () => ({ bestCredentialIndex: void 0 });
+	const defaults = () => ({});
 	const create = (() => {
 		return uniffiCreateRecord(defaults);
 	})();
@@ -4826,17 +5258,15 @@ const FfiConverterTypeRecoverySummary = (() => {
 		readFromCursor(c) {
 			return {
 				status: FfiConverterTypeRecoveryStatus.readFromCursor(c),
-				bestCredentialIndex: FfiConverterOptionalUInt32.readFromCursor(c),
 				issues: FfiConverterSequenceTypeRecoveryIssue.readFromCursor(c)
 			};
 		}
 		writeIntoCursor(value, c) {
 			FfiConverterTypeRecoveryStatus.writeIntoCursor(value.status, c);
-			FfiConverterOptionalUInt32.writeIntoCursor(value.bestCredentialIndex, c);
 			FfiConverterSequenceTypeRecoveryIssue.writeIntoCursor(value.issues, c);
 		}
 		allocationSize(value) {
-			return FfiConverterTypeRecoveryStatus.allocationSize(value.status) + FfiConverterOptionalUInt32.allocationSize(value.bestCredentialIndex) + FfiConverterSequenceTypeRecoveryIssue.allocationSize(value.issues);
+			return FfiConverterTypeRecoveryStatus.allocationSize(value.status) + FfiConverterSequenceTypeRecoveryIssue.allocationSize(value.issues);
 		}
 	}
 	return new FFIConverter();
@@ -4845,15 +5275,21 @@ let GoldenComparison_Tags = /* @__PURE__ */ function(GoldenComparison_Tags) {
 	GoldenComparison_Tags["NotRequested"] = "NotRequested";
 	GoldenComparison_Tags["NoEmbeddedManifest"] = "NoEmbeddedManifest";
 	GoldenComparison_Tags["NoRecoveredManifest"] = "NoRecoveredManifest";
+	GoldenComparison_Tags["RecoveryIncomplete"] = "RecoveryIncomplete";
 	GoldenComparison_Tags["Matches"] = "Matches";
 	GoldenComparison_Tags["Differs"] = "Differs";
-	GoldenComparison_Tags["Indeterminate"] = "Indeterminate";
+	GoldenComparison_Tags["NoneMatches"] = "NoneMatches";
+	GoldenComparison_Tags["Unreadable"] = "Unreadable";
 	return GoldenComparison_Tags;
 }({});
 /**
-* Typed completion of C2PA 2.4's `watermark-golden` / `fingerprint-golden` final comparison.
+* Typed completion of C2PA 2.4's `watermark-golden` / `fingerprint-golden` final comparison:
+* the local active manifest against what the registry holds. Every outcome is its own variant.
 */
 const GoldenComparison = (() => {
+	/**
+	* `recovery.when` is `whenMissing`, so nothing was recovered beside a valid manifest.
+	*/
 	class NotRequested_ extends UniffiEnum {
 		/**
 		* @private
@@ -4871,6 +5307,9 @@ const GoldenComparison = (() => {
 			return obj.tag === "NotRequested";
 		}
 	}
+	/**
+	* These bytes carry no manifest, so there is nothing to compare the registry's against.
+	*/
 	class NoEmbeddedManifest_ extends UniffiEnum {
 		/**
 		* @private
@@ -4888,6 +5327,9 @@ const GoldenComparison = (() => {
 			return obj.tag === "NoEmbeddedManifest";
 		}
 	}
+	/**
+	* Recovery finished and the registry holds nothing for these bytes.
+	*/
 	class NoRecoveredManifest_ extends UniffiEnum {
 		/**
 		* @private
@@ -4905,6 +5347,29 @@ const GoldenComparison = (() => {
 			return obj.tag === "NoRecoveredManifest";
 		}
 	}
+	/**
+	* Recovery did not finish, so nothing is claimed either way.
+	*/
+	class RecoveryIncomplete_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "GoldenComparison";
+		tag = "RecoveryIncomplete";
+		constructor() {
+			super("GoldenComparison", "RecoveryIncomplete");
+		}
+		static new() {
+			return new RecoveryIncomplete_();
+		}
+		static instanceOf(obj) {
+			return obj.tag === "RecoveryIncomplete";
+		}
+	}
+	/**
+	* A recovered manifest is the embedded one, claim for claim.
+	*/
 	class Matches_ extends UniffiEnum {
 		/**
 		* @private
@@ -4924,6 +5389,9 @@ const GoldenComparison = (() => {
 			return obj.tag === "Matches";
 		}
 	}
+	/**
+	* The one recovered manifest is not the embedded one: what a substitution looks like.
+	*/
 	class Differs_ extends UniffiEnum {
 		/**
 		* @private
@@ -4943,25 +5411,48 @@ const GoldenComparison = (() => {
 			return obj.tag === "Differs";
 		}
 	}
-	class Indeterminate_ extends UniffiEnum {
+	/**
+	* Several recovered manifests and none is the embedded one, by index.
+	*/
+	class NoneMatches_ extends UniffiEnum {
 		/**
 		* @private
 		* This field is private and should not be used, use `tag` instead.
 		*/
 		[uniffiTypeNameSymbol] = "GoldenComparison";
-		tag = "Indeterminate";
+		tag = "NoneMatches";
 		inner;
 		constructor(inner) {
-			super("GoldenComparison", "Indeterminate");
+			super("GoldenComparison", "NoneMatches");
 			this.inner = Object.freeze(inner);
 		}
-		static new = (() => {
-			const defaults = () => ({ recoveredIndex: void 0 });
-			const create = uniffiCreateRecord(defaults);
-			return (partial) => new Indeterminate_(create(partial));
-		})();
+		static new(inner) {
+			return new NoneMatches_(inner);
+		}
 		static instanceOf(obj) {
-			return obj.tag === "Indeterminate";
+			return obj.tag === "NoneMatches";
+		}
+	}
+	/**
+	* The one recovered manifest has no active manifest to compare.
+	*/
+	class Unreadable_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "GoldenComparison";
+		tag = "Unreadable";
+		inner;
+		constructor(inner) {
+			super("GoldenComparison", "Unreadable");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Unreadable_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Unreadable";
 		}
 	}
 	function instanceOf(obj) {
@@ -4972,9 +5463,11 @@ const GoldenComparison = (() => {
 		NotRequested: NotRequested_,
 		NoEmbeddedManifest: NoEmbeddedManifest_,
 		NoRecoveredManifest: NoRecoveredManifest_,
+		RecoveryIncomplete: RecoveryIncomplete_,
 		Matches: Matches_,
 		Differs: Differs_,
-		Indeterminate: Indeterminate_
+		NoneMatches: NoneMatches_,
+		Unreadable: Unreadable_
 	});
 })();
 const FfiConverterTypeGoldenComparison = (() => {
@@ -4984,9 +5477,11 @@ const FfiConverterTypeGoldenComparison = (() => {
 				case 1: return new GoldenComparison.NotRequested();
 				case 2: return new GoldenComparison.NoEmbeddedManifest();
 				case 3: return new GoldenComparison.NoRecoveredManifest();
-				case 4: return new GoldenComparison.Matches({ recoveredIndex: FfiConverterUInt32.readFromCursor(c) });
-				case 5: return new GoldenComparison.Differs({ recoveredIndex: FfiConverterUInt32.readFromCursor(c) });
-				case 6: return new GoldenComparison.Indeterminate({ recoveredIndex: FfiConverterOptionalUInt32.readFromCursor(c) });
+				case 4: return new GoldenComparison.RecoveryIncomplete();
+				case 5: return new GoldenComparison.Matches({ recoveredIndex: FfiConverterUInt32.readFromCursor(c) });
+				case 6: return new GoldenComparison.Differs({ recoveredIndex: FfiConverterUInt32.readFromCursor(c) });
+				case 7: return new GoldenComparison.NoneMatches({ candidates: FfiConverterSequenceUInt32.readFromCursor(c) });
+				case 8: return new GoldenComparison.Unreadable({ recoveredIndex: FfiConverterUInt32.readFromCursor(c) });
 				default: throw new UniffiInternalError.UnexpectedEnumCase();
 			}
 		}
@@ -5001,22 +5496,31 @@ const FfiConverterTypeGoldenComparison = (() => {
 				case "NoRecoveredManifest":
 					c.writeI32(3);
 					return;
-				case "Matches": {
+				case "RecoveryIncomplete":
 					c.writeI32(4);
+					return;
+				case "Matches": {
+					c.writeI32(5);
 					const inner = value.inner;
 					FfiConverterUInt32.writeIntoCursor(inner.recoveredIndex, c);
 					return;
 				}
 				case "Differs": {
-					c.writeI32(5);
+					c.writeI32(6);
 					const inner = value.inner;
 					FfiConverterUInt32.writeIntoCursor(inner.recoveredIndex, c);
 					return;
 				}
-				case "Indeterminate": {
-					c.writeI32(6);
+				case "NoneMatches": {
+					c.writeI32(7);
 					const inner = value.inner;
-					FfiConverterOptionalUInt32.writeIntoCursor(inner.recoveredIndex, c);
+					FfiConverterSequenceUInt32.writeIntoCursor(inner.candidates, c);
+					return;
+				}
+				case "Unreadable": {
+					c.writeI32(8);
+					const inner = value.inner;
+					FfiConverterUInt32.writeIntoCursor(inner.recoveredIndex, c);
 					return;
 				}
 				default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -5027,6 +5531,7 @@ const FfiConverterTypeGoldenComparison = (() => {
 				case "NotRequested": return 4;
 				case "NoEmbeddedManifest": return 4;
 				case "NoRecoveredManifest": return 4;
+				case "RecoveryIncomplete": return 4;
 				case "Matches": {
 					const inner = value.inner;
 					let size = 4;
@@ -5039,10 +5544,306 @@ const FfiConverterTypeGoldenComparison = (() => {
 					size += FfiConverterUInt32.allocationSize(inner.recoveredIndex);
 					return size;
 				}
-				case "Indeterminate": {
+				case "NoneMatches": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterSequenceUInt32.allocationSize(inner.candidates);
+					return size;
+				}
+				case "Unreadable": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterUInt32.allocationSize(inner.recoveredIndex);
+					return size;
+				}
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+	}
+	return new FFIConverter();
+})();
+/**
+* The evidence that singled a recovered verdict out.
+*/
+let VerdictRule = /* @__PURE__ */ function(VerdictRule) {
+	VerdictRule[VerdictRule["OnlyCandidate"] = 0] = "OnlyCandidate";
+	/**
+	* Every other candidate is superseded by a credential in this report.
+	*/
+	VerdictRule[VerdictRule["NotSuperseded"] = 1] = "NotSuperseded";
+	/**
+	* Its hash holds over these bytes and no other unsuperseded candidate's does.
+	*/
+	VerdictRule[VerdictRule["HardBinding"] = 2] = "HardBinding";
+	return VerdictRule;
+}({});
+const FfiConverterTypeVerdictRule = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			switch (c.readI32()) {
+				case 1: return 0;
+				case 2: return 1;
+				case 3: return 2;
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+		writeIntoCursor(value, c) {
+			switch (value) {
+				case 0: return c.writeI32(1);
+				case 1: return c.writeI32(2);
+				case 2: return c.writeI32(3);
+			}
+		}
+		allocationSize(value) {
+			return 4;
+		}
+	}
+	return new FFIConverter();
+})();
+let Verdict_Tags = /* @__PURE__ */ function(Verdict_Tags) {
+	Verdict_Tags["Unsigned"] = "Unsigned";
+	Verdict_Tags["Inconclusive"] = "Inconclusive";
+	Verdict_Tags["Embedded"] = "Embedded";
+	Verdict_Tags["Recovered"] = "Recovered";
+	Verdict_Tags["RecoveredDerivative"] = "RecoveredDerivative";
+	Verdict_Tags["Ambiguous"] = "Ambiguous";
+	return Verdict_Tags;
+}({});
+/**
+* What this verify concludes about the asset, chosen from [`AssetVerification::credentials`]
+* on signed evidence alone. Policy over the evidence: no credential's validation state changes,
+* and the list stays whole beside it.
+*
+* The embedded manifest is the verdict whenever the asset carries one that is not `Invalid`
+* and the golden comparison does not contradict it. When it `differs` from what the registry
+* holds, or several recovered candidates leave the comparison indeterminate, the embedded and
+* the recovered manifests are reported as ambiguous: C2PA 2.4's substitution use case leaves
+* that trust decision to the client. Otherwise a recovered candidate is named only when
+* evidence singles it out: it is the only one, or the only one no other credential in this
+* report supersedes (the successor's signed `parentOf` link), or the only one of those whose
+* hard binding holds over these bytes. A registry score, a signature time or a position in the
+* list is not evidence of which manifest belongs to these bytes, so candidates those alone would
+* separate are reported as ambiguous.
+*/
+const Verdict = (() => {
+	/**
+	* No credential, and recovery either was not requested or finished with nothing.
+	*/
+	class Unsigned_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "Verdict";
+		tag = "Unsigned";
+		constructor() {
+			super("Verdict", "Unsigned");
+		}
+		static new() {
+			return new Unsigned_();
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Unsigned";
+		}
+	}
+	/**
+	* No credential, and recovery did not finish: unsigned cannot be claimed.
+	*/
+	class Inconclusive_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "Verdict";
+		tag = "Inconclusive";
+		constructor() {
+			super("Verdict", "Inconclusive");
+		}
+		static new() {
+			return new Inconclusive_();
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Inconclusive";
+		}
+	}
+	/**
+	* The manifest the asset carries, always the first credential. An `Invalid` one is the
+	* verdict only when nothing was recovered.
+	*/
+	class Embedded_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "Verdict";
+		tag = "Embedded";
+		constructor() {
+			super("Verdict", "Embedded");
+		}
+		static new() {
+			return new Embedded_();
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Embedded";
+		}
+	}
+	/**
+	* A recovered manifest whose hard binding holds over these bytes.
+	*/
+	class Recovered_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "Verdict";
+		tag = "Recovered";
+		inner;
+		constructor(inner) {
+			super("Verdict", "Recovered");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Recovered_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Recovered";
+		}
+	}
+	/**
+	* A recovered manifest for an earlier state of these bytes: its hard binding mismatches.
+	*/
+	class RecoveredDerivative_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "Verdict";
+		tag = "RecoveredDerivative";
+		inner;
+		constructor(inner) {
+			super("Verdict", "RecoveredDerivative");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new RecoveredDerivative_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "RecoveredDerivative";
+		}
+	}
+	/**
+	* Manifests that no signed evidence separates, by index: several recovered ones, or the
+	* embedded one beside what the registry holds when the golden comparison contradicts it.
+	* Which one a product shows is its own rule.
+	*/
+	class Ambiguous_ extends UniffiEnum {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "Verdict";
+		tag = "Ambiguous";
+		inner;
+		constructor(inner) {
+			super("Verdict", "Ambiguous");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Ambiguous_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Ambiguous";
+		}
+	}
+	function instanceOf(obj) {
+		return obj[uniffiTypeNameSymbol] === "Verdict";
+	}
+	return Object.freeze({
+		instanceOf,
+		Unsigned: Unsigned_,
+		Inconclusive: Inconclusive_,
+		Embedded: Embedded_,
+		Recovered: Recovered_,
+		RecoveredDerivative: RecoveredDerivative_,
+		Ambiguous: Ambiguous_
+	});
+})();
+const FfiConverterTypeVerdict = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			switch (c.readI32()) {
+				case 1: return new Verdict.Unsigned();
+				case 2: return new Verdict.Inconclusive();
+				case 3: return new Verdict.Embedded();
+				case 4: return new Verdict.Recovered({
+					index: FfiConverterUInt32.readFromCursor(c),
+					decidedBy: FfiConverterTypeVerdictRule.readFromCursor(c)
+				});
+				case 5: return new Verdict.RecoveredDerivative({
+					index: FfiConverterUInt32.readFromCursor(c),
+					decidedBy: FfiConverterTypeVerdictRule.readFromCursor(c)
+				});
+				case 6: return new Verdict.Ambiguous({ candidates: FfiConverterSequenceUInt32.readFromCursor(c) });
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+		writeIntoCursor(value, c) {
+			switch (value.tag) {
+				case "Unsigned":
+					c.writeI32(1);
+					return;
+				case "Inconclusive":
+					c.writeI32(2);
+					return;
+				case "Embedded":
+					c.writeI32(3);
+					return;
+				case "Recovered": {
+					c.writeI32(4);
+					const inner = value.inner;
+					FfiConverterUInt32.writeIntoCursor(inner.index, c);
+					FfiConverterTypeVerdictRule.writeIntoCursor(inner.decidedBy, c);
+					return;
+				}
+				case "RecoveredDerivative": {
+					c.writeI32(5);
+					const inner = value.inner;
+					FfiConverterUInt32.writeIntoCursor(inner.index, c);
+					FfiConverterTypeVerdictRule.writeIntoCursor(inner.decidedBy, c);
+					return;
+				}
+				case "Ambiguous": {
+					c.writeI32(6);
+					const inner = value.inner;
+					FfiConverterSequenceUInt32.writeIntoCursor(inner.candidates, c);
+					return;
+				}
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+		allocationSize(value) {
+			switch (value.tag) {
+				case "Unsigned": return 4;
+				case "Inconclusive": return 4;
+				case "Embedded": return 4;
+				case "Recovered": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterUInt32.allocationSize(inner.index);
+					size += FfiConverterTypeVerdictRule.allocationSize(inner.decidedBy);
+					return size;
+				}
+				case "RecoveredDerivative": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterUInt32.allocationSize(inner.index);
+					size += FfiConverterTypeVerdictRule.allocationSize(inner.decidedBy);
+					return size;
+				}
+				case "Ambiguous": {
 					const inner = value.inner;
 					let size = 4;
-					size += FfiConverterOptionalUInt32.allocationSize(inner.recoveredIndex);
+					size += FfiConverterSequenceUInt32.allocationSize(inner.candidates);
 					return size;
 				}
 				default: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -5071,16 +5872,18 @@ const FfiConverterTypeAssetVerification = (() => {
 			return {
 				credentials: FfiConverterSequenceTypeFoundCredential.readFromCursor(c),
 				recovery: FfiConverterTypeRecoverySummary.readFromCursor(c),
-				goldenComparison: FfiConverterTypeGoldenComparison.readFromCursor(c)
+				goldenComparison: FfiConverterTypeGoldenComparison.readFromCursor(c),
+				verdict: FfiConverterTypeVerdict.readFromCursor(c)
 			};
 		}
 		writeIntoCursor(value, c) {
 			FfiConverterSequenceTypeFoundCredential.writeIntoCursor(value.credentials, c);
 			FfiConverterTypeRecoverySummary.writeIntoCursor(value.recovery, c);
 			FfiConverterTypeGoldenComparison.writeIntoCursor(value.goldenComparison, c);
+			FfiConverterTypeVerdict.writeIntoCursor(value.verdict, c);
 		}
 		allocationSize(value) {
-			return FfiConverterSequenceTypeFoundCredential.allocationSize(value.credentials) + FfiConverterTypeRecoverySummary.allocationSize(value.recovery) + FfiConverterTypeGoldenComparison.allocationSize(value.goldenComparison);
+			return FfiConverterSequenceTypeFoundCredential.allocationSize(value.credentials) + FfiConverterTypeRecoverySummary.allocationSize(value.recovery) + FfiConverterTypeGoldenComparison.allocationSize(value.goldenComparison) + FfiConverterTypeVerdict.allocationSize(value.verdict);
 		}
 	}
 	return new FFIConverter();
@@ -5089,7 +5892,7 @@ const FfiConverterTypeAssetVerification = (() => {
 * Generated factory for {@link RegistryOptions} record objects.
 */
 const RegistryOptions = (() => {
-	const defaults = () => ({ endpoints: void 0 });
+	const defaults = () => ({ endpoints: [] });
 	const create = (() => {
 		return uniffiCreateRecord(defaults);
 	})();
@@ -5104,15 +5907,15 @@ const FfiConverterTypeRegistryOptions = (() => {
 		readFromCursor(c) {
 			return {
 				url: FfiConverterString.readFromCursor(c),
-				endpoints: FfiConverterOptionalSequenceString.readFromCursor(c)
+				endpoints: FfiConverterSequenceString.readFromCursor(c)
 			};
 		}
 		writeIntoCursor(value, c) {
 			FfiConverterString.writeIntoCursor(value.url, c);
-			FfiConverterOptionalSequenceString.writeIntoCursor(value.endpoints, c);
+			FfiConverterSequenceString.writeIntoCursor(value.endpoints, c);
 		}
 		allocationSize(value) {
-			return FfiConverterString.allocationSize(value.url) + FfiConverterOptionalSequenceString.allocationSize(value.endpoints);
+			return FfiConverterString.allocationSize(value.url) + FfiConverterSequenceString.allocationSize(value.endpoints);
 		}
 	}
 	return new FFIConverter();
@@ -5693,7 +6496,7 @@ let RecoveryPolicy = /* @__PURE__ */ function(RecoveryPolicy) {
 	* It queries the registry on every verify, without making it load-bearing on the asset's own
 	* credential: the flow provides information about a substitution rather than gating the local
 	* manifest, so a registry that cannot be reached leaves [`RecoveryStatus::Incomplete`], the
-	* reason as a [`RecoveryIssue`], and [`GoldenComparison::Indeterminate`]. A caller for whom a
+	* reason as a [`RecoveryIssue`], and [`GoldenComparison::RecoveryIncomplete`]. A caller for whom a
 	* cross-check that never ran must not pass for agreement branches on that status.
 	*/
 	RecoveryPolicy[RecoveryPolicy["Always"] = 1] = "Always";
@@ -6734,7 +7537,7 @@ var AssetVerifier = class extends UniffiAbstractObject {
 		}, FfiConverterString.lift.bind(FfiConverterString)));
 	}
 	/**
-	* Verify an asset from a [`RangeSource`] using the per-call binders and recovery plan.
+	* Verify an asset from a [`RangeSource`] using the per-call binders and recovery options.
 	* `plugins` carries the caller's
 	* plugins for non-c2pa formats (e.g. MXF); pass an empty `PluginRegistry` for a
 	* built-in C2PA media format. The SDK links no plugin itself. Returns embedded/recovered
@@ -7359,6 +8162,7 @@ const FfiConverterMapStringTypeManifest = new FfiConverterMap(FfiConverterString
 const FfiConverterOptionalTypeValidationState = new FfiConverterOptional(FfiConverterTypeValidationState);
 const FfiConverterSequenceTypeFoundCredential = new FfiConverterArray(FfiConverterTypeFoundCredential);
 const FfiConverterSequenceTypeRecoveryIssue = new FfiConverterArray(FfiConverterTypeRecoveryIssue);
+const FfiConverterSequenceUInt32 = new FfiConverterArray(FfiConverterUInt32);
 const FfiConverterOptionalTypeRegistryOptions = new FfiConverterOptional(FfiConverterTypeRegistryOptions);
 const FfiConverterSequenceTypeValidationCode = new FfiConverterArray(FfiConverterTypeValidationCode);
 const FfiConverterSequenceTypeSessionKeySummary = new FfiConverterArray(FfiConverterTypeSessionKeySummary);
@@ -7392,7 +8196,7 @@ function uniffiEnsureInitialized() {
 	if (getter().uniffi_trylimbo_sdk_verifier_checksum_func_resource() !== 40984) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_func_resource");
 	if (getter().uniffi_trylimbo_sdk_verifier_checksum_func_thumbnails() !== 52018) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_func_thumbnails");
 	if (getter().uniffi_trylimbo_sdk_verifier_checksum_constructor_assetverifier_create() !== 14882) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_constructor_assetverifier_create");
-	if (getter().uniffi_trylimbo_sdk_verifier_checksum_method_assetverifier_verify() !== 37299) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_method_assetverifier_verify");
+	if (getter().uniffi_trylimbo_sdk_verifier_checksum_method_assetverifier_verify() !== 16580) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_method_assetverifier_verify");
 	if (getter().uniffi_trylimbo_sdk_verifier_checksum_constructor_binder_custom() !== 3866) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_constructor_binder_custom");
 	if (getter().uniffi_trylimbo_sdk_verifier_checksum_constructor_binder_held() !== 1096) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_constructor_binder_held");
 	if (getter().uniffi_trylimbo_sdk_verifier_checksum_constructor_binder_iscc() !== 47287) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_verifier_checksum_constructor_binder_iscc");
@@ -7466,7 +8270,6 @@ var trylimbo_verifier_default = Object.freeze({
 		FfiConverterTypeRecovery,
 		FfiConverterTypeRecoveryDiscovery,
 		FfiConverterTypeRecoveryIssue,
-		FfiConverterTypeRecoveryIssueKind,
 		FfiConverterTypeRecoveryPolicy,
 		FfiConverterTypeRecoveryStatus,
 		FfiConverterTypeRecoverySummary,
@@ -7504,6 +8307,8 @@ var trylimbo_verifier_default = Object.freeze({
 		FfiConverterTypeValidationState,
 		FfiConverterTypeValidationStatus,
 		FfiConverterTypeValue,
+		FfiConverterTypeVerdict,
+		FfiConverterTypeVerdictRule,
 		FfiConverterTypeVerifyOptions
 	}
 });
@@ -7517,4 +8322,4 @@ if (!initialized) {
 async function uniffiInitAsync() {}
 var ffi_trylimbo_sdk_verifier_default = { trylimbo_verifier: trylimbo_verifier_exports };
 //#endregion
-export { Actor, AssertionMetadata, AssetType, AssetVerification, AssetVerifier, AssetVerifierOptions, Binder, ByContent, ByReference, ClaimGeneratorInfo, Code, ContentBindingClass, ContentTrigger, Coordinate, CredentialOrigin, CredentialOrigin_Tags, DataSource, DeriveOptions, Detectors, Detectors_Tags, EndInclusivity, FieldViolation, FileSource, FingerprintCheck, FingerprintCheck_Tags, FoundCredential, Frame, GoldenComparison, GoldenComparison_Tags, HardBinding, HashedUri, Ingredient, IngredientDeltaValidationResult, InitValidation, Item, Lineage, Manifest, ManifestAssertion, ManifestAssertionKind, ManifestStore, MediaValidation, MemorySource, PluginRegistry, Range, RangeSourceImpl, RangeType, Recovery, RecoveryDiscovery, RecoveryDiscovery_Tags, RecoveryIssue, RecoveryIssueKind, RecoveryPolicy, RecoveryStatus, RecoverySummary, Region, RegionOfInterest, RegistryOptions, Relationship, ResourceRef, ReviewRating, Role, SdkError, SdkError_Tags, SegmentTiming, SegmentValidation, SegmentValidation_Tags, SessionKeySummary, Shape, ShapeType, SignatureInfo, SigningAlgSchema, SoftBinding, StatusCodes, StreamValidation, StreamVerifier, StreamVerifierOptions, Text, TextSelector, TextSelectorRange, Time, TimeType, UnitType, UriOrResource, UriOrResource_Tags, ValidationCode, ValidationCodeKind, ValidationResults, ValidationState, ValidationStatus, VerifyOptions, c2paTrustList, c2paTsaTrustList, ffi_trylimbo_sdk_verifier_default as default, devCa, parse, resource, thumbnails, uniffiInitAsync };
+export { Actor, AssertionMetadata, AssetType, AssetVerification, AssetVerifier, AssetVerifierOptions, Binder, ByContent, ByReference, ClaimGeneratorInfo, Code, ContentBindingClass, ContentTrigger, Coordinate, CredentialOrigin, CredentialOrigin_Tags, DataSource, DeriveOptions, Detectors, Detectors_Tags, EndInclusivity, FieldViolation, FileSource, FingerprintCheck, FingerprintCheck_Tags, FoundCredential, Frame, GoldenComparison, GoldenComparison_Tags, HardBinding, HashedUri, Ingredient, IngredientDeltaValidationResult, InitValidation, Item, Lineage, Manifest, ManifestAssertion, ManifestAssertionKind, ManifestStore, MediaValidation, MemorySource, PluginRegistry, Range, RangeSourceImpl, RangeType, Recovery, RecoveryDiscovery, RecoveryDiscovery_Tags, RecoveryIssue, RecoveryIssue_Tags, RecoveryPolicy, RecoveryStatus, RecoverySummary, Region, RegionOfInterest, RegistryOptions, Relationship, ResourceRef, ReviewRating, Role, SdkError, SdkError_Tags, SegmentTiming, SegmentValidation, SegmentValidation_Tags, SessionKeySummary, Shape, ShapeType, SignatureInfo, SigningAlgSchema, SoftBinding, StatusCodes, StreamValidation, StreamVerifier, StreamVerifierOptions, Text, TextSelector, TextSelectorRange, Time, TimeType, UnitType, UriOrResource, UriOrResource_Tags, ValidationCode, ValidationCodeKind, ValidationResults, ValidationState, ValidationStatus, Verdict, VerdictRule, Verdict_Tags, VerifyOptions, c2paTrustList, c2paTsaTrustList, ffi_trylimbo_sdk_verifier_default as default, devCa, parse, resource, thumbnails, uniffiInitAsync };