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

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

}

public enum ConductionValidationError: Error {
   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
      }
   }
   
   public var errors: [(keys: [String], message: String)] {
      switch self {
      case .values(_, _, let errors): return errors.map { return (keys: [$0.key], message: $0.message) }
      case .consistency(_, _, let errors): return errors
      }
   }
   
