 }
 
 public enum ConductionValidationError: Error {
-   case values(selfType: String, keys: [String], message: String, errors: [String : String])
-   case consistency(selfType: String, keys: [[String]], message: String, errors: [String : String])
+   case values(selfType: String, message: String, errors: [(key: String, message: String)])
+   case consistency(selfType: String, message: String, errors: [(keys: [String], message: String)])
    
    // MARK: - Public Properties
    public var message: String {
       switch self {
-      case .values(_, _, let message, _): return message
-      case .consistency(_, _, let message, _): return message
+      case .values(_, let message, _): return message
+      case .consistency(_, let message, _): return message
       }
    }
-   public var errors: [String : String] {
+   
+   public var errors: [(keys: [String], message: String)] {
       switch self {
-      case .values(_, _, _, let errors): return errors
-      case .consistency(_, _, _, let errors): return errors
+      case .values(_, _, let errors): return errors.map { return (keys: [$0.key], message: $0.message) }
+      case .consistency(_, _, let errors): return errors
       }
    }
    

   
   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)
      }
   }
}
