| // Copyright 2026 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #ifndef THIRD_PARTY_CREDENTIO_CONSTANTS_STATUS_CODES_H_ |
| #define THIRD_PARTY_CREDENTIO_CONSTANTS_STATUS_CODES_H_ |
| |
| #include "absl/strings/str_cat.h" |
| |
| namespace credentio { |
| |
| // Constants corresponding to C2PA status codes. |
| // See |
| // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_standard_status_codes |
| // for more information. about the C2PA status codes. Integer ranges for |
| // success/informational/failure are disjoint to be safe. |
| |
| // Success status codes. |
| // See |
| // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_success_codes. |
| enum class SuccessStatusCode { |
| kClaimSignatureValidated = 201, // claimSignature.validated |
| kClaimSignatureInsideValidity, // claimSignature.insideValidity |
| |
| // Custom success codes, specific to this validator. |
| kGoogleAssertionDataHashMatch, // com.google.assertion.dataHash.match |
| kGoogleAssertionBmffHashMatch, // com.google.assertion.bmffHash.match |
| kGoogleAssertionBoxesHashMatch, // com.google.assertion.boxesHash.match |
| // com.google.assertion.multiAssetHash.match |
| kGoogleAssertionMultiAssetHashMatch, |
| // com.google.assertion.collectionHash.match |
| kGoogleAssertionCollectionHashMatch, |
| kAssertionDataHashMatch, // assertion.dataHash.match |
| kIngredientClaimSignatureValidated, // ingredient.claimSignature.validated |
| kIngredientManifestValidated, // ingredient.manifest.validated |
| kAssertionHashedUriMatch, // assertion.hashedURI.match |
| kAssertionBmffHashMatch, // assertion.bmffHash.match |
| kAssertionBoxesHashMatch, // assertion.boxesHash.match |
| kAssertionCollectionHashMatch, // assertion.collectionHash.match |
| kAssertionMultiAssetHashMatch, // assertion.multiAssetHash.match |
| kSigningCredentialTrusted, // signingCredential.trusted |
| kTimestampTrusted, // timeStamp.trusted |
| kTimestampValidated, // timeStamp.validated |
| kSigningCredentialOcspNotRevoked, // signingCredential.ocsp.notRevoked |
| }; |
| |
| // Informational status codes. |
| // See |
| // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_informational_codes. |
| enum class InformationalStatusCode { |
| // Custom informational codes, specific to this validator |
| // go/keep-sorted start |
| // Indicates that the OCSP response's `producedAt` timestamp is outside of the |
| // certificate's validity period or the timestamp's time is outside of the |
| // validity window of the stapled OCSP response. |
| kSigningCredentialOcspOutsideValidity = 601, |
| // com.google.signingCredential.ocsp.outsideValidity |
| // Indicates that the timestamp's time is outside of the range that can be |
| // handled by this validator. The timestamp may be considered valid by |
| // other implementations. |
| kTimestampOutOfRange, // com.google.timeStamp.outOfRange |
| kTimestampV1FormatInV2Header, // com.google.timeStamp.V1FormatInV2Header |
| kTimestampV2MessageImprintInV1Format, |
| // com.google.timeStamp.V2MessageImprintInV1Format |
| // go/keep-sorted end |
| |
| // Standard informational codes |
| // go/keep-sorted start |
| kIngredientUnknownProvenance, // ingredient.unknownProvenance |
| kSigningCredentialOcspSkipped, // signingCredential.ocsp.skipped |
| kTimestampMalformed, // timeStamp.malformed |
| kTimestampMismatch, // timeStamp.mismatch |
| kTimestampOutsideValidity, // timeStamp.outsideValidity |
| kTimestampUntrusted, // timeStamp.untrusted |
| // go/keep-sorted end |
| |
| // Assertion informational codes |
| // go/keep-sorted start |
| // assertion.bmffHash.additionalExclusionsPresent |
| kAssertionBmffHashAdditionalExclusionsPresent, |
| // assertion.boxesHash.additionalExclusionsPresent |
| kAssertionBoxesHashAdditionalExclusionsPresent, |
| // assertion.dataHash.additionalExclusionsPresent |
| kAssertionDataHashAdditionalExclusionsPresent, |
| // go/keep-sorted end |
| }; |
| |
| // Failure status codes. |
| // See |
| // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_failure_codes. |
| enum class FailureStatusCode { |
| kGeneralError = 401, // (custom, name TBD) |
| |
| // Custom failure codes, specific to this validator. |
| kGoogleInternalError, // com.google.internal.error |
| kGoogleUnsupportedSpecVersion, // com.google.unsupportedSpecVersion |
| kGoogleUnsupportedManifestType, // com.google.unsupportedManifestType |
| // com.google.assertion.action.unknownAction |
| kGoogleAssertionActionUnknownAction, |
| kGoogleAssertionDataHashMismatch, // com.google.assertion.dataHash.mismatch |
| kGoogleAssertionDataHashMalformed, // com.google.assertion.dataHash.malformed |
| kGoogleAssertionBmffHashMalformed, // com.google.assertion.bmffHash.malformed |
| kGoogleAssertionBmffHashMismatch, // com.google.assertion.bmffHash.mismatch |
| // com.google.assertion.boxesHash.unknownBox |
| kGoogleAssertionBoxesHashUnknownBox, |
| kGoogleAssertionBoxesHashMismatch, // com.google.assertion.boxesHash.mismatch |
| // com.google.assertion.boxesHash.malformed |
| kGoogleAssertionBoxesHashMalformed, |
| // com.google.assertion.multiAssetHash.mismatch |
| kGoogleAssertionMultiAssetHashMismatch, |
| // com.google.assertion.multiAssetHash.malformed |
| kGoogleAssertionMultiAssetHashMalformed, |
| // com.google.assertion.multiAssetHash.missingPart |
| kGoogleAssertionMultiAssetHashMissingPart, |
| kGoogleHashedUriUnsupported, // com.google.hashedUri.unsupported |
| |
| // Failure codes used for C2PA Claim validation. |
| kAlgorithmUnsupported, // algorithm.unsupported |
| kClaimHardBindingsMissing, // claim.hardBindings.missing |
| kClaimMalformed, // claim.malformed |
| kClaimMissing, // claim.missing |
| kClaimMultiple, // claim.multiple |
| kClaimCborInvalid, // claim.cbor.invalid |
| kClaimSignatureMissing, // claimSignature.missing |
| kClaimSignatureMismatch, // claimSignature.mismatch |
| kClaimSignatureOutsideValidity, // claimSignature.outsideValidity |
| kHashedUriMissing, // hashedUri.missing |
| kSigningCredentialInvalid, // signingCredential.invalid |
| kSigningCredentialOcspRevoked, // signingCredential.ocsp.revoked |
| kSigningCredentialUntrusted, // signingCredential.untrusted |
| |
| // Failure codes used for C2PA Assertion validation. |
| kAssertionCborInvalid, // assertion.cbor.invalid |
| kAssertionJsonInvalid, // assertion.json.invalid |
| kAssertionMultipleHardBindings, // assertion.multipleHardBindings |
| kAssertionDataHashMismatch, // assertion.dataHash.mismatch |
| kAssertionDataHashMalformed, // assertion.dataHash.malformed |
| kAssertionUndeclared, // assertion.undeclared |
| kAssertionOutsideManifest, // assertion.outsideManifest |
| kAssertionMissing, // assertion.missing |
| kAssertionHashedUriMismatch, // assertion.hashedURI.mismatch |
| kAssertionNotRedacted, // assertion.notRedacted |
| kAssertionSelfRedacted, // assertion.selfRedacted |
| kAssertionBmffHashMalformed, // assertion.bmffHash.malformed |
| kAssertionBmffHashMismatch, // assertion.bmffHash.mismatch |
| kAssertionBoxesHashUnknownBox, // assertion.boxesHash.unknownBox |
| kAssertionBoxesHashMismatch, // assertion.boxesHash.mismatch |
| kAssertionBoxesHashMalformed, // assertion.boxesHash.malformed |
| kAssertionMultiAssetHashMismatch, // assertion.multiAssetHash.mismatch |
| kAssertionMultiAssetHashMalformed, // assertion.multiAssetHash.malformed |
| kAssertionMultiAssetHashMissingPart, // assertion.multiAssetHash.missingPart |
| // assertion.collectionHash.incorrectFileCount |
| kAssertionCollectionHashIncorrectFileCount, |
| // assertion.collectionHash.invalidURI |
| kAssertionCollectionHashInvalidUri, |
| kAssertionCollectionHashMismatch, // assertion.collectionHash.mismatch |
| kAssertionCollectionHashMalformed, // assertion.collectionHash.malformed |
| kAssertionActionRedacted, // assertion.action.redacted |
| kAssertionActionMalformed, // assertion.action.malformed |
| kAssertionActionSoftBindingMissing, // assertion.action.softBindingMissing |
| kAssertionActionIngredientMismatch, // assertion.action.ingredientMismatch |
| kAssertionActionRedactionMismatch, // assertion.action.redactionMismatch |
| kAssertionIngredientMalformed, // assertion.ingredient.malformed |
| kHashedUriMismatch, // hashedUri.mismatch |
| |
| // Failure codes related to C2PA ingredient manifests |
| kIngredientClaimSignatureMissing, // ingredient.claimSignature.missing |
| kIngredientClaimSignatureMismatch, // ingredient.claimSignature.mismatch |
| kIngredientManifestMissing, // ingredient.manifest.missing |
| kIngredientManifestMismatch, // ingredient.manifest.mismatch |
| |
| kManifestMultipleParents, // manifest.multipleParents |
| kManifestUpdateInvalid, // manifest.update.invalid |
| kManifestUpdateWrongParents, // manifest.update.wrongParents |
| }; |
| |
| template <typename Sink> |
| void AbslStringify(Sink& sink, SuccessStatusCode status) { |
| switch (status) { |
| case SuccessStatusCode::kClaimSignatureValidated: |
| sink.Append("claimSignature.validated"); |
| return; |
| case SuccessStatusCode::kClaimSignatureInsideValidity: |
| sink.Append("claimSignature.insideValidity"); |
| return; |
| case SuccessStatusCode::kAssertionDataHashMatch: |
| sink.Append("assertion.dataHash.match"); |
| return; |
| case SuccessStatusCode::kIngredientManifestValidated: |
| sink.Append("ingredient.manifest.validated"); |
| return; |
| case SuccessStatusCode::kIngredientClaimSignatureValidated: |
| sink.Append("ingredient.claimSignature.validated"); |
| return; |
| case SuccessStatusCode::kAssertionHashedUriMatch: |
| sink.Append("assertion.hashedURI.match"); |
| return; |
| case SuccessStatusCode::kAssertionBmffHashMatch: |
| sink.Append("assertion.bmffHash.match"); |
| return; |
| case SuccessStatusCode::kAssertionBoxesHashMatch: |
| sink.Append("assertion.boxesHash.match"); |
| return; |
| case SuccessStatusCode::kAssertionCollectionHashMatch: |
| sink.Append("assertion.collectionHash.match"); |
| return; |
| case SuccessStatusCode::kSigningCredentialTrusted: |
| sink.Append("signingCredential.trusted"); |
| return; |
| case SuccessStatusCode::kTimestampTrusted: |
| sink.Append("timeStamp.trusted"); |
| return; |
| case SuccessStatusCode::kTimestampValidated: |
| sink.Append("timeStamp.validated"); |
| return; |
| case SuccessStatusCode::kSigningCredentialOcspNotRevoked: |
| sink.Append("signingCredential.ocsp.notRevoked"); |
| return; |
| case SuccessStatusCode::kGoogleAssertionDataHashMatch: |
| sink.Append("com.google.assertion.dataHash.match"); |
| return; |
| case SuccessStatusCode::kGoogleAssertionCollectionHashMatch: |
| sink.Append("com.google.assertion.collectionHash.match"); |
| return; |
| case SuccessStatusCode::kGoogleAssertionBmffHashMatch: |
| sink.Append("com.google.assertion.bmffHash.match"); |
| return; |
| case SuccessStatusCode::kGoogleAssertionBoxesHashMatch: |
| sink.Append("com.google.assertion.boxesHash.match"); |
| return; |
| case SuccessStatusCode::kGoogleAssertionMultiAssetHashMatch: |
| sink.Append("com.google.assertion.multiAssetHash.match"); |
| return; |
| case SuccessStatusCode::kAssertionMultiAssetHashMatch: |
| sink.Append("assertion.multiAssetHash.match"); |
| return; |
| } |
| sink.Append( |
| absl::StrCat("UNKNOWN_SUCCESS_STATUS_", static_cast<int>(status))); |
| } |
| |
| template <typename Sink> |
| void AbslStringify(Sink& sink, InformationalStatusCode status) { |
| switch (status) { |
| case credentio::InformationalStatusCode:: |
| kSigningCredentialOcspOutsideValidity: |
| sink.Append("com.google.signingCredential.ocsp.outsideValidity"); |
| return; |
| case credentio::InformationalStatusCode::kTimestampOutOfRange: |
| sink.Append("com.google.timeStamp.outOfRange"); |
| return; |
| case InformationalStatusCode::kTimestampV1FormatInV2Header: |
| sink.Append("com.google.timeStamp.V1FormatInV2Header"); |
| return; |
| case InformationalStatusCode::kTimestampV2MessageImprintInV1Format: |
| sink.Append("com.google.timeStamp.V2MessageImprintInV1Format"); |
| return; |
| case InformationalStatusCode::kIngredientUnknownProvenance: |
| sink.Append("ingredient.unknownProvenance"); |
| return; |
| case InformationalStatusCode::kTimestampMalformed: |
| sink.Append("timeStamp.malformed"); |
| return; |
| case InformationalStatusCode::kTimestampUntrusted: |
| sink.Append("timeStamp.untrusted"); |
| return; |
| case credentio::InformationalStatusCode::kTimestampOutsideValidity: |
| sink.Append("timeStamp.outsideValidity"); |
| return; |
| case InformationalStatusCode::kSigningCredentialOcspSkipped: |
| sink.Append("signingCredential.ocsp.skipped"); |
| return; |
| case InformationalStatusCode::kTimestampMismatch: |
| sink.Append("timeStamp.mismatch"); |
| return; |
| case InformationalStatusCode::kAssertionDataHashAdditionalExclusionsPresent: |
| sink.Append("assertion.dataHash.additionalExclusionsPresent"); |
| return; |
| case InformationalStatusCode:: |
| kAssertionBoxesHashAdditionalExclusionsPresent: |
| sink.Append("assertion.boxesHash.additionalExclusionsPresent"); |
| return; |
| case InformationalStatusCode::kAssertionBmffHashAdditionalExclusionsPresent: |
| sink.Append("assertion.bmffHash.additionalExclusionsPresent"); |
| return; |
| } |
| sink.Append( |
| absl::StrCat("UNKNOWN_INFORMATIONAL_STATUS_", static_cast<int>(status))); |
| } |
| |
| template <typename Sink> |
| void AbslStringify(Sink& sink, FailureStatusCode status) { |
| switch (status) { |
| case FailureStatusCode::kGeneralError: |
| sink.Append("general.error"); |
| return; |
| case FailureStatusCode::kGoogleInternalError: |
| sink.Append("com.google.internal.error"); |
| return; |
| case FailureStatusCode::kGoogleUnsupportedSpecVersion: |
| sink.Append("com.google.unsupportedSpecVersion"); |
| return; |
| case FailureStatusCode::kGoogleUnsupportedManifestType: |
| sink.Append("com.google.unsupportedManifestType"); |
| return; |
| case FailureStatusCode::kClaimMissing: |
| sink.Append("claim.missing"); |
| return; |
| case FailureStatusCode::kClaimMultiple: |
| sink.Append("claim.multiple"); |
| return; |
| case FailureStatusCode::kClaimCborInvalid: |
| sink.Append("claim.cbor.invalid"); |
| return; |
| case FailureStatusCode::kClaimSignatureMissing: |
| sink.Append("claimSignature.missing"); |
| return; |
| case FailureStatusCode::kClaimSignatureMismatch: |
| sink.Append("claimSignature.mismatch"); |
| return; |
| case FailureStatusCode::kClaimSignatureOutsideValidity: |
| sink.Append("claimSignature.outsideValidity"); |
| return; |
| case FailureStatusCode::kHashedUriMissing: |
| sink.Append("hashedUri.missing"); |
| return; |
| case FailureStatusCode::kSigningCredentialInvalid: |
| sink.Append("signingCredential.invalid"); |
| return; |
| case FailureStatusCode::kSigningCredentialUntrusted: |
| sink.Append("signingCredential.untrusted"); |
| return; |
| case FailureStatusCode::kAssertionCborInvalid: |
| sink.Append("assertion.cbor.invalid"); |
| return; |
| case FailureStatusCode::kAssertionJsonInvalid: |
| sink.Append("assertion.json.invalid"); |
| return; |
| case FailureStatusCode::kClaimHardBindingsMissing: |
| sink.Append("claim.hardBindings.missing"); |
| return; |
| case FailureStatusCode::kClaimMalformed: |
| sink.Append("claim.malformed"); |
| return; |
| case FailureStatusCode::kAssertionMultipleHardBindings: |
| sink.Append("assertion.multipleHardBindings"); |
| return; |
| case FailureStatusCode::kAssertionDataHashMismatch: |
| sink.Append("assertion.dataHash.mismatch"); |
| return; |
| case FailureStatusCode::kAlgorithmUnsupported: |
| sink.Append("algorithm.unsupported"); |
| return; |
| case FailureStatusCode::kAssertionDataHashMalformed: |
| sink.Append("assertion.dataHash.malformed"); |
| return; |
| case FailureStatusCode::kAssertionUndeclared: |
| sink.Append("assertion.undeclared"); |
| return; |
| case FailureStatusCode::kAssertionOutsideManifest: |
| sink.Append("assertion.outsideManifest"); |
| return; |
| case FailureStatusCode::kAssertionMissing: |
| sink.Append("assertion.missing"); |
| return; |
| case FailureStatusCode::kIngredientClaimSignatureMissing: |
| sink.Append("ingredient.claimSignature.missing"); |
| return; |
| case FailureStatusCode::kIngredientClaimSignatureMismatch: |
| sink.Append("ingredient.claimSignature.mismatch"); |
| return; |
| case FailureStatusCode::kIngredientManifestMissing: |
| sink.Append("ingredient.manifest.missing"); |
| return; |
| case FailureStatusCode::kIngredientManifestMismatch: |
| sink.Append("ingredient.manifest.mismatch"); |
| return; |
| case FailureStatusCode::kAssertionHashedUriMismatch: |
| sink.Append("assertion.hashedURI.mismatch"); |
| return; |
| case FailureStatusCode::kAssertionNotRedacted: |
| sink.Append("assertion.notRedacted"); |
| return; |
| case FailureStatusCode::kAssertionSelfRedacted: |
| sink.Append("assertion.selfRedacted"); |
| return; |
| case FailureStatusCode::kAssertionBmffHashMalformed: |
| sink.Append("assertion.bmffHash.malformed"); |
| return; |
| case FailureStatusCode::kAssertionBmffHashMismatch: |
| sink.Append("assertion.bmffHash.mismatch"); |
| return; |
| case FailureStatusCode::kAssertionBoxesHashUnknownBox: |
| sink.Append("assertion.boxesHash.unknownBox"); |
| return; |
| case FailureStatusCode::kAssertionBoxesHashMismatch: |
| sink.Append("assertion.boxesHash.mismatch"); |
| return; |
| case FailureStatusCode::kGoogleAssertionActionUnknownAction: |
| sink.Append("com.google.assertion.action.unknownAction"); |
| return; |
| case FailureStatusCode::kAssertionActionRedacted: |
| sink.Append("assertion.action.redacted"); |
| return; |
| case FailureStatusCode::kAssertionActionMalformed: |
| sink.Append("assertion.action.malformed"); |
| return; |
| case FailureStatusCode::kAssertionActionSoftBindingMissing: |
| sink.Append("assertion.action.softBindingMissing"); |
| return; |
| case FailureStatusCode::kAssertionActionIngredientMismatch: |
| sink.Append("assertion.action.ingredientMismatch"); |
| return; |
| case FailureStatusCode::kAssertionActionRedactionMismatch: |
| sink.Append("assertion.action.redactionMismatch"); |
| return; |
| case FailureStatusCode::kAssertionIngredientMalformed: |
| sink.Append("assertion.ingredient.malformed"); |
| return; |
| case FailureStatusCode::kHashedUriMismatch: |
| sink.Append("hashedUri.mismatch"); |
| return; |
| case FailureStatusCode::kManifestMultipleParents: |
| sink.Append("manifest.multipleParents"); |
| return; |
| case FailureStatusCode::kManifestUpdateInvalid: |
| sink.Append("manifest.update.invalid"); |
| return; |
| case FailureStatusCode::kManifestUpdateWrongParents: |
| sink.Append("manifest.update.wrongParents"); |
| return; |
| case FailureStatusCode::kSigningCredentialOcspRevoked: |
| sink.Append("signingCredential.ocsp.revoked"); |
| return; |
| case FailureStatusCode::kGoogleAssertionDataHashMismatch: |
| sink.Append("com.google.assertion.dataHash.mismatch"); |
| return; |
| case FailureStatusCode::kGoogleAssertionDataHashMalformed: |
| sink.Append("com.google.assertion.dataHash.malformed"); |
| return; |
| case FailureStatusCode::kGoogleAssertionBmffHashMalformed: |
| sink.Append("com.google.assertion.bmffHash.malformed"); |
| return; |
| case FailureStatusCode::kGoogleAssertionBmffHashMismatch: |
| sink.Append("com.google.assertion.bmffHash.mismatch"); |
| return; |
| case FailureStatusCode::kGoogleAssertionBoxesHashUnknownBox: |
| sink.Append("com.google.assertion.boxesHash.unknownBox"); |
| return; |
| case FailureStatusCode::kGoogleAssertionBoxesHashMismatch: |
| sink.Append("com.google.assertion.boxesHash.mismatch"); |
| return; |
| case FailureStatusCode::kGoogleHashedUriUnsupported: |
| sink.Append("com.google.hashedUri.unsupported"); |
| return; |
| case FailureStatusCode::kAssertionBoxesHashMalformed: |
| sink.Append("assertion.boxesHash.malformed"); |
| return; |
| case FailureStatusCode::kGoogleAssertionBoxesHashMalformed: |
| sink.Append("com.google.assertion.boxesHash.malformed"); |
| return; |
| case FailureStatusCode::kGoogleAssertionMultiAssetHashMismatch: |
| sink.Append("com.google.assertion.multiAssetHash.mismatch"); |
| return; |
| case FailureStatusCode::kGoogleAssertionMultiAssetHashMalformed: |
| sink.Append("com.google.assertion.multiAssetHash.malformed"); |
| return; |
| case FailureStatusCode::kGoogleAssertionMultiAssetHashMissingPart: |
| sink.Append("com.google.assertion.multiAssetHash.missingPart"); |
| return; |
| case FailureStatusCode::kAssertionMultiAssetHashMismatch: |
| sink.Append("assertion.multiAssetHash.mismatch"); |
| return; |
| case FailureStatusCode::kAssertionMultiAssetHashMalformed: |
| sink.Append("assertion.multiAssetHash.malformed"); |
| return; |
| case FailureStatusCode::kAssertionMultiAssetHashMissingPart: |
| sink.Append("assertion.multiAssetHash.missingPart"); |
| return; |
| case FailureStatusCode::kAssertionCollectionHashIncorrectFileCount: |
| sink.Append("assertion.collectionHash.incorrectFileCount"); |
| return; |
| case FailureStatusCode::kAssertionCollectionHashInvalidUri: |
| sink.Append("assertion.collectionHash.invalidURI"); |
| return; |
| case FailureStatusCode::kAssertionCollectionHashMismatch: |
| sink.Append("assertion.collectionHash.mismatch"); |
| return; |
| case FailureStatusCode::kAssertionCollectionHashMalformed: |
| sink.Append("assertion.collectionHash.malformed"); |
| return; |
| } |
| sink.Append( |
| absl::StrCat("UNKNOWN_FAILURE_STATUS_", static_cast<int>(status))); |
| } |
| |
| } // namespace credentio |
| |
| #endif // THIRD_PARTY_CREDENTIO_CONSTANTS_STATUS_CODES_H_ |
