update existing enums that have an 'unknown' value to not throw on unrecognized values

@@ -20,7 +20,7 @@ enum AddressType {
       case 2:
       case 2:
         return AddressType.home;
         return AddressType.home;
       default:
       default:
-        throw ArgumentError.value(value, 'value', 'Invalid raw value.');
+        return AddressType.unknown;
     }
     }
   }
   }
 
 

@@ -70,7 +70,7 @@ enum BarcodeType {
       case 12:
       case 12:
         return BarcodeType.driverLicense;
         return BarcodeType.driverLicense;
       default:
       default:
-        throw ArgumentError.value(value, 'value', 'Invalid raw value.');
+        return BarcodeType.unknown;
     }
     }
   }
   }
 
 

@@ -20,7 +20,7 @@ enum EmailType {
       case 2:
       case 2:
         return EmailType.home;
         return EmailType.home;
       default:
       default:
-        throw ArgumentError.value(value, 'value', 'Invalid raw value.');
+        return EmailType.unknown;
     }
     }
   }
   }
 
 

@@ -30,7 +30,7 @@ enum PhoneType {
       case 4:
       case 4:
         return PhoneType.mobile;
         return PhoneType.mobile;
       default:
       default:
-        throw ArgumentError.value(value, 'value', 'Invalid raw value.');
+        return PhoneType.unknown;
     }
     }
   }
   }
 
 

@@ -17,12 +17,12 @@ void main() {
       }
       }
     });
     });
 
 
-    test('invalid raw value throws argument error', () {
+    test('invalid raw value returns AddressType.unknown', () {
       const int negative = -1;
       const int negative = -1;
       const int outOfRange = 3;
       const int outOfRange = 3;
 
 
-      expect(() => AddressType.fromRawValue(negative), throwsArgumentError);
-      expect(() => AddressType.fromRawValue(outOfRange), throwsArgumentError);
+      expect(() => AddressType.fromRawValue(negative), AddressType.unknown);
+      expect(() => AddressType.fromRawValue(outOfRange), AddressType.unknown);
     });
     });
 
 
     test('can be converted to raw value', () {
     test('can be converted to raw value', () {

@@ -27,12 +27,12 @@ void main() {
       }
       }
     });
     });
 
 
-    test('invalid raw value throws argument error', () {
+    test('invalid raw value returns BarcodeType.unknown', () {
       const int negative = -1;
       const int negative = -1;
       const int outOfRange = 13;
       const int outOfRange = 13;
 
 
-      expect(() => BarcodeType.fromRawValue(negative), throwsArgumentError);
-      expect(() => BarcodeType.fromRawValue(outOfRange), throwsArgumentError);
+      expect(() => BarcodeType.fromRawValue(negative), BarcodeType.unknown);
+      expect(() => BarcodeType.fromRawValue(outOfRange), BarcodeType.unknown);
     });
     });
 
 
     test('can be converted to raw value', () {
     test('can be converted to raw value', () {

@@ -17,12 +17,12 @@ void main() {
       }
       }
     });
     });
 
 
-    test('invalid raw value throws argument error', () {
+    test('invalid raw value returns EmailType.unknown', () {
       const int negative = -1;
       const int negative = -1;
       const int outOfRange = 3;
       const int outOfRange = 3;
 
 
-      expect(() => EmailType.fromRawValue(negative), throwsArgumentError);
-      expect(() => EmailType.fromRawValue(outOfRange), throwsArgumentError);
+      expect(() => EmailType.fromRawValue(negative), EmailType.unknown);
+      expect(() => EmailType.fromRawValue(outOfRange), EmailType.unknown);
     });
     });
 
 
     test('can be converted to raw value', () {
     test('can be converted to raw value', () {

@@ -19,12 +19,12 @@ void main() {
       }
       }
     });
     });
 
 
-    test('invalid raw value throws argument error', () {
+    test('invalid raw value returns PhoneType.unknown', () {
       const int negative = -1;
       const int negative = -1;
       const int outOfRange = 5;
       const int outOfRange = 5;
 
 
-      expect(() => PhoneType.fromRawValue(negative), throwsArgumentError);
-      expect(() => PhoneType.fromRawValue(outOfRange), throwsArgumentError);
+      expect(() => PhoneType.fromRawValue(negative), PhoneType.unknown);
+      expect(() => PhoneType.fromRawValue(outOfRange), PhoneType.unknown);
     });
     });
 
 
     test('can be converted to raw value', () {
     test('can be converted to raw value', () {