          }
          }.isEmpty
       
-      guard invalidKeys.isEmpty, !hasValueSubErrors else {
-         let keyStrings = invalidKeys.map { $0.rawValue }
-         var validationError: ConductionValidationError = .values(selfType: "\(type(of: self))", keys: keyStrings, message: validationContext, errors: errors)
+      guard invalidErrors.isEmpty, !hasValueSubErrors else {
+         var validationError: ConductionValidationError = .values(selfType: "\(type(of: self))", message: validationContext, errors: invalidErrors)
          validationError.consolidate(with: subErrors)
          return validationError
       }
       
-      var inconsistentKeyStringGroups: [[String]] = []
+      var consistencyErrors: [(keys: [String], message: String)] = []
       consistencyErrorMessages.forEach {
          let keyStrings = $0.keys.map { return $0.rawValue }
-         inconsistentKeyStringGroups.append(keyStrings)
-         errors[keyStrings.joined(separator: ",")] = $0.message
+         consistencyErrors.append((keys: keyStrings, message: $0.message))
       }
-      guard inconsistentKeyStringGroups.isEmpty, subErrors.isEmpty else {
-         var validationError: ConductionValidationError = .consistency(selfType: "\(type(of: self))", keys: inconsistentKeyStringGroups, message: validationContext, errors: errors)
+      guard consistencyErrors.isEmpty, subErrors.isEmpty else {
+         var validationError: ConductionValidationError = .consistency(selfType: "\(type(of: self))", message: validationContext, errors: consistencyErrors)
          validationError.consolidate(with: subErrors)
          return validationError
       }

   
   var validationError: ConductionValidationError? {
      let subErrors = errorsForKeys
      var errors: [String : String] = [:]
      var invalidKeys: [Key] = []
      Key.all.forEach {
         guard let errorMessage = validationErrorMessageForKey($0) else { return }
         invalidKeys.append($0)
         errors[$0.rawValue] = errorMessage
      }
      let hasValueSubErrors = !subErrors.filter {
         switch $1 {

      guard !errorsForKeys.isEmpty else { return }
      
      switch self {
      case .values(let selfType, let message, var errors):
         errorsForKeys.forEach { key, error in
            switch error {
            case .values(_, _, let subErrors):
               errors.append(contentsOf: subErrors.map { return (key: "\(key).\($0.key)", message: $0.message) })
            case .consistency: return
            }
         }
         self = .values(selfType: selfType, message: message, errors: errors)
      case .consistency(let selfType, let message, var errors):
         errorsForKeys.forEach { key, error in
            switch error {
            case .values: return
            case .consistency(_, _, let subErrors):
               errors.append(contentsOf: subErrors.map { return (keys: $0.keys.map { "\(key).\($0)" }, message: $0.message) })
            }
         }
         self = .consistency(selfType: selfType, message: message, errors: errors)
      }
   }
}
