more tests for the api by_table types

crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs

@@ -166,9 +166,10 @@ impl FrontendFailureCategory {
 #[cfg(test)]
 mod tests {
   use crate::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
-  use crate::test_helpers::assert_serialization;
+  use crate::test_helpers::{assert_deserialization, assert_serialization};
+  use strum::IntoEnumIterator;
 
-  mod explicit_checks {
+  mod manual_checks {
     use super::*;
 
     #[test]
@@ -188,6 +189,28 @@ mod tests {
       assert_serialization(FrontendFailureCategory::GenerationFailed, "generation_failed");
     }
 
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("face_not_detected", FrontendFailureCategory::FaceNotDetected);
+      assert_deserialization("keep_alive_elapsed", FrontendFailureCategory::KeepAliveElapsed);
+      assert_deserialization("not_yet_implemented", FrontendFailureCategory::NotYetImplemented);
+      assert_deserialization("retryable_worker_error", FrontendFailureCategory::RetryableWorkerError);
+      assert_deserialization("model_rules_violation", FrontendFailureCategory::ModelRulesViolation);
+      assert_deserialization("rule_bans_user_image", FrontendFailureCategory::RuleBansUserImage);
+      assert_deserialization("rule_bans_user_image_with_faces", FrontendFailureCategory::RuleBansUserImageWithFaces);
+      assert_deserialization("rule_bans_user_text_prompt", FrontendFailureCategory::RuleBansUserTextPrompt);
+      assert_deserialization("rule_bans_user_content", FrontendFailureCategory::RuleBansUserContent);
+      assert_deserialization("rule_bans_generated_video", FrontendFailureCategory::RuleBansGeneratedVideo);
+      assert_deserialization("rule_bans_generated_audio", FrontendFailureCategory::RuleBansGeneratedAudio);
+      assert_deserialization("rule_bans_generated_content", FrontendFailureCategory::RuleBansGeneratedContent);
+      assert_deserialization("generation_failed", FrontendFailureCategory::GenerationFailed);
+    }
+
+    #[test]
+    fn variants_count_check() {
+      assert_eq!(FrontendFailureCategory::iter().count(), 13);
+    }
+
     #[test]
     fn to_str() {
       assert_eq!(FrontendFailureCategory::FaceNotDetected.to_str(), "face_not_detected");
@@ -249,7 +272,6 @@ mod tests {
 
     #[test]
     fn variant_length() {
-      use strum::IntoEnumIterator;
       assert_eq!(FrontendFailureCategory::all_variants().len(), FrontendFailureCategory::iter().len());
     }
 
@@ -261,5 +283,14 @@ mod tests {
         assert_eq!(variant, FrontendFailureCategory::from_str(&format!("{:?}", variant)).unwrap());
       }
     }
+
+    #[test]
+    fn round_trip_json() {
+      for variant in FrontendFailureCategory::iter() {
+        let json = serde_json::to_string(&variant).unwrap();
+        let back: FrontendFailureCategory = serde_json::from_str(&json).unwrap();
+        assert_eq!(variant, back);
+      }
+    }
   }
 }

crates/schema/public/enums/src/by_table/model_weights/weights_types.rs

@@ -89,50 +89,89 @@ impl_mysql_from_row!(WeightsType);
 #[cfg(test)]
 mod tests {
   use super::*;
+  use crate::test_helpers::{assert_deserialization, assert_serialization};
+  use strum::IntoEnumIterator;
 
-  #[test]
-  fn test_to_str() {
-    assert_eq!(WeightsType::HifiganTacotron2.to_str(), "hifigan_tt2");
-    assert_eq!(WeightsType::RvcV2.to_str(), "rvc_v2");
-    assert_eq!(WeightsType::StableDiffusion15.to_str(), "sd_1.5");
-    assert_eq!(WeightsType::StableDiffusionXL.to_str(), "sdxl");
-    assert_eq!(WeightsType::SoVitsSvc.to_str(), "so_vits_svc");
-    assert_eq!(WeightsType::Tacotron2.to_str(), "tt2");
-    assert_eq!(WeightsType::LoRA.to_str(), "loRA");
-    assert_eq!(WeightsType::VallE.to_str(), "vall_e");
-    assert_eq!(WeightsType::ComfyUi.to_str(), "comfy_ui");
-    assert_eq!(WeightsType::GptSoVits.to_str(), "gpt_so_vits");
-  }
+  mod manual_checks {
+    use super::*;
 
-  #[test]
-  fn test_from_str() {
-    assert_eq!(WeightsType::from_str("hifigan_tt2").unwrap(), WeightsType::HifiganTacotron2);
-    assert_eq!(WeightsType::from_str("rvc_v2").unwrap(), WeightsType::RvcV2);
-    assert_eq!(WeightsType::from_str("sd_1.5").unwrap(), WeightsType::StableDiffusion15);
-    assert_eq!(WeightsType::from_str("sdxl").unwrap(), WeightsType::StableDiffusionXL);
-    assert_eq!(WeightsType::from_str("so_vits_svc").unwrap(), WeightsType::SoVitsSvc);
-    assert_eq!(WeightsType::from_str("tt2").unwrap(), WeightsType::Tacotron2);
-    assert_eq!(WeightsType::from_str("loRA").unwrap(), WeightsType::LoRA);
-    assert_eq!(WeightsType::from_str("vall_e").unwrap(), WeightsType::VallE);
-    assert_eq!(WeightsType::from_str("comfy_ui").unwrap(), WeightsType::ComfyUi);
-    assert_eq!(WeightsType::from_str("gpt_so_vits").unwrap(), WeightsType::GptSoVits);
-    assert!(WeightsType::from_str("invalid").is_err());
-  }
+    #[test]
+    fn test_serialization() {
+      assert_serialization(WeightsType::HifiganTacotron2, "hifigan_tt2");
+      assert_serialization(WeightsType::RvcV2, "rvc_v2");
+      assert_serialization(WeightsType::StableDiffusion15, "sd_1.5");
+      assert_serialization(WeightsType::StableDiffusionXL, "sdxl");
+      assert_serialization(WeightsType::SoVitsSvc, "so_vits_svc");
+      assert_serialization(WeightsType::Tacotron2, "tt2");
+      assert_serialization(WeightsType::LoRA, "loRA");
+      assert_serialization(WeightsType::VallE, "vall_e");
+      assert_serialization(WeightsType::ComfyUi, "comfy_ui");
+      assert_serialization(WeightsType::GptSoVits, "gpt_so_vits");
+    }
 
-  #[test]
-  fn test_all_variants() {
-    let variants = WeightsType::all_variants();
-    assert_eq!(variants.len(), 10);
-    assert!(variants.contains(&WeightsType::HifiganTacotron2));
-    assert!(variants.contains(&WeightsType::RvcV2));
-    assert!(variants.contains(&WeightsType::StableDiffusion15));
-    assert!(variants.contains(&WeightsType::StableDiffusionXL));
-    assert!(variants.contains(&WeightsType::SoVitsSvc));
-    assert!(variants.contains(&WeightsType::Tacotron2));
-    assert!(variants.contains(&WeightsType::LoRA));
-    assert!(variants.contains(&WeightsType::VallE));
-    assert!(variants.contains(&WeightsType::ComfyUi));
-    assert!(variants.contains(&WeightsType::GptSoVits));
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("hifigan_tt2", WeightsType::HifiganTacotron2);
+      assert_deserialization("rvc_v2", WeightsType::RvcV2);
+      assert_deserialization("sd_1.5", WeightsType::StableDiffusion15);
+      assert_deserialization("sdxl", WeightsType::StableDiffusionXL);
+      assert_deserialization("so_vits_svc", WeightsType::SoVitsSvc);
+      assert_deserialization("tt2", WeightsType::Tacotron2);
+      assert_deserialization("loRA", WeightsType::LoRA);
+      assert_deserialization("vall_e", WeightsType::VallE);
+      assert_deserialization("comfy_ui", WeightsType::ComfyUi);
+      assert_deserialization("gpt_so_vits", WeightsType::GptSoVits);
+    }
+
+    #[test]
+    fn variants_count_check() {
+      assert_eq!(WeightsType::iter().count(), 10);
+    }
+
+    #[test]
+    fn to_str() {
+      assert_eq!(WeightsType::HifiganTacotron2.to_str(), "hifigan_tt2");
+      assert_eq!(WeightsType::RvcV2.to_str(), "rvc_v2");
+      assert_eq!(WeightsType::StableDiffusion15.to_str(), "sd_1.5");
+      assert_eq!(WeightsType::StableDiffusionXL.to_str(), "sdxl");
+      assert_eq!(WeightsType::SoVitsSvc.to_str(), "so_vits_svc");
+      assert_eq!(WeightsType::Tacotron2.to_str(), "tt2");
+      assert_eq!(WeightsType::LoRA.to_str(), "loRA");
+      assert_eq!(WeightsType::VallE.to_str(), "vall_e");
+      assert_eq!(WeightsType::ComfyUi.to_str(), "comfy_ui");
+      assert_eq!(WeightsType::GptSoVits.to_str(), "gpt_so_vits");
+    }
+
+    #[test]
+    fn from_str() {
+      assert_eq!(WeightsType::from_str("hifigan_tt2").unwrap(), WeightsType::HifiganTacotron2);
+      assert_eq!(WeightsType::from_str("rvc_v2").unwrap(), WeightsType::RvcV2);
+      assert_eq!(WeightsType::from_str("sd_1.5").unwrap(), WeightsType::StableDiffusion15);
+      assert_eq!(WeightsType::from_str("sdxl").unwrap(), WeightsType::StableDiffusionXL);
+      assert_eq!(WeightsType::from_str("so_vits_svc").unwrap(), WeightsType::SoVitsSvc);
+      assert_eq!(WeightsType::from_str("tt2").unwrap(), WeightsType::Tacotron2);
+      assert_eq!(WeightsType::from_str("loRA").unwrap(), WeightsType::LoRA);
+      assert_eq!(WeightsType::from_str("vall_e").unwrap(), WeightsType::VallE);
+      assert_eq!(WeightsType::from_str("comfy_ui").unwrap(), WeightsType::ComfyUi);
+      assert_eq!(WeightsType::from_str("gpt_so_vits").unwrap(), WeightsType::GptSoVits);
+      assert!(WeightsType::from_str("invalid").is_err());
+    }
+
+    #[test]
+    fn all_variants() {
+      let variants = WeightsType::all_variants();
+      assert_eq!(variants.len(), 10);
+      assert!(variants.contains(&WeightsType::HifiganTacotron2));
+      assert!(variants.contains(&WeightsType::RvcV2));
+      assert!(variants.contains(&WeightsType::StableDiffusion15));
+      assert!(variants.contains(&WeightsType::StableDiffusionXL));
+      assert!(variants.contains(&WeightsType::SoVitsSvc));
+      assert!(variants.contains(&WeightsType::Tacotron2));
+      assert!(variants.contains(&WeightsType::LoRA));
+      assert!(variants.contains(&WeightsType::VallE));
+      assert!(variants.contains(&WeightsType::ComfyUi));
+      assert!(variants.contains(&WeightsType::GptSoVits));
+    }
   }
 
   mod mechanical_checks {
@@ -140,7 +179,6 @@ mod tests {
 
     #[test]
     fn variant_length() {
-      use strum::IntoEnumIterator;
       assert_eq!(WeightsType::all_variants().len(), WeightsType::iter().len());
     }
 
@@ -153,6 +191,15 @@ mod tests {
       }
     }
 
+    #[test]
+    fn round_trip_json() {
+      for variant in WeightsType::iter() {
+        let json = serde_json::to_string(&variant).unwrap();
+        let back: WeightsType = serde_json::from_str(&json).unwrap();
+        assert_eq!(variant, back);
+      }
+    }
+
     #[test]
     fn serialized_length_ok_for_database() {
       const MAX_LENGTH : usize = 16;

crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_action.rs

@@ -33,11 +33,32 @@ pub enum AuditLogEntityAction {
 #[cfg(test)]
 mod tests {
   use super::AuditLogEntityAction;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(AuditLogEntityAction::Create, "create");
+      assert_serialization(AuditLogEntityAction::Edit, "edit");
+      assert_serialization(AuditLogEntityAction::EditFeatures, "edit_features");
+      assert_serialization(AuditLogEntityAction::Delete, "delete");
+      assert_serialization(AuditLogEntityAction::FeaturedItemCreate, "featured_item_create");
+      assert_serialization(AuditLogEntityAction::FeaturedItemDelete, "featured_item_delete");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("create", AuditLogEntityAction::Create);
+      assert_deserialization("edit", AuditLogEntityAction::Edit);
+      assert_deserialization("edit_features", AuditLogEntityAction::EditFeatures);
+      assert_deserialization("delete", AuditLogEntityAction::Delete);
+      assert_deserialization("featured_item_create", AuditLogEntityAction::FeaturedItemCreate);
+      assert_deserialization("featured_item_delete", AuditLogEntityAction::FeaturedItemDelete);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(AuditLogEntityAction::iter().count(), 6);

crates/schema/public/enums_api/src/by_table/audit_logs/audit_log_entity_type.rs

@@ -25,11 +25,28 @@ pub enum AuditLogEntityType {
 #[cfg(test)]
 mod tests {
   use super::AuditLogEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(AuditLogEntityType::Comment, "comment");
+      assert_serialization(AuditLogEntityType::MediaFile, "media_file");
+      assert_serialization(AuditLogEntityType::ModelWeight, "model_weight");
+      assert_serialization(AuditLogEntityType::User, "user");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("comment", AuditLogEntityType::Comment);
+      assert_deserialization("media_file", AuditLogEntityType::MediaFile);
+      assert_deserialization("model_weight", AuditLogEntityType::ModelWeight);
+      assert_deserialization("user", AuditLogEntityType::User);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(AuditLogEntityType::iter().count(), 4);

crates/schema/public/enums_api/src/by_table/batch_generations/batch_generation_entity_type.rs

@@ -14,11 +14,22 @@ pub enum BatchGenerationEntityType {
 #[cfg(test)]
 mod tests {
   use super::BatchGenerationEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(BatchGenerationEntityType::MediaFile, "media_file");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", BatchGenerationEntityType::MediaFile);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(BatchGenerationEntityType::iter().count(), 1);

crates/schema/public/enums_api/src/by_table/beta_keys/beta_key_product.rs

@@ -14,11 +14,22 @@ pub enum BetaKeyProduct {
 #[cfg(test)]
 mod tests {
   use super::BetaKeyProduct;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(BetaKeyProduct::Studio, "studio");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("studio", BetaKeyProduct::Studio);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(BetaKeyProduct::iter().count(), 1);

crates/schema/public/enums_api/src/by_table/comments/comment_entity_type.rs

@@ -37,11 +37,34 @@ pub enum CommentEntityType {
 #[cfg(test)]
 mod tests {
   use super::CommentEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(CommentEntityType::User, "user");
+      assert_serialization(CommentEntityType::MediaFile, "media_file");
+      assert_serialization(CommentEntityType::ModelWeight, "model_weight");
+      assert_serialization(CommentEntityType::TtsModel, "tts_model");
+      assert_serialization(CommentEntityType::TtsResult, "tts_result");
+      assert_serialization(CommentEntityType::W2lTemplate, "w2l_template");
+      assert_serialization(CommentEntityType::W2lResult, "w2l_result");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("user", CommentEntityType::User);
+      assert_deserialization("media_file", CommentEntityType::MediaFile);
+      assert_deserialization("model_weight", CommentEntityType::ModelWeight);
+      assert_deserialization("tts_model", CommentEntityType::TtsModel);
+      assert_deserialization("tts_result", CommentEntityType::TtsResult);
+      assert_deserialization("w2l_template", CommentEntityType::W2lTemplate);
+      assert_deserialization("w2l_result", CommentEntityType::W2lResult);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(CommentEntityType::iter().count(), 7);

crates/schema/public/enums_api/src/by_table/email_sender_jobs/email_category.rs

@@ -21,11 +21,24 @@ pub enum EmailCategory {
 #[cfg(test)]
 mod tests {
   use super::EmailCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(EmailCategory::Welcome, "welcome");
+      assert_serialization(EmailCategory::PasswordReset, "password_reset");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("welcome", EmailCategory::Welcome);
+      assert_deserialization("password_reset", EmailCategory::PasswordReset);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(EmailCategory::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/entity_stats/stats_entity_type.rs

@@ -21,11 +21,26 @@ pub enum StatsEntityType {
 #[cfg(test)]
 mod tests {
   use super::StatsEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(StatsEntityType::Comment, "comment");
+      assert_serialization(StatsEntityType::MediaFile, "media_file");
+      assert_serialization(StatsEntityType::ModelWeight, "model_weight");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("comment", StatsEntityType::Comment);
+      assert_deserialization("media_file", StatsEntityType::MediaFile);
+      assert_deserialization("model_weight", StatsEntityType::ModelWeight);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(StatsEntityType::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/featured_items/featured_item_entity_type.rs

@@ -21,11 +21,26 @@ pub enum FeaturedItemEntityType {
 #[cfg(test)]
 mod tests {
   use super::FeaturedItemEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(FeaturedItemEntityType::MediaFile, "media_file");
+      assert_serialization(FeaturedItemEntityType::ModelWeight, "model_weight");
+      assert_serialization(FeaturedItemEntityType::User, "user");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", FeaturedItemEntityType::MediaFile);
+      assert_deserialization("model_weight", FeaturedItemEntityType::ModelWeight);
+      assert_deserialization("user", FeaturedItemEntityType::User);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(FeaturedItemEntityType::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/generic_download_jobs/generic_download_type.rs

@@ -58,11 +58,36 @@ pub enum GenericDownloadType {
 #[cfg(test)]
 mod tests {
   use super::GenericDownloadType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(GenericDownloadType::HifiGan, "hifigan");
+      assert_serialization(GenericDownloadType::HifiGanRocketVc, "hifigan_rocket_vc");
+      assert_serialization(GenericDownloadType::HifiGanSoVitsSvc, "hifigan_so_vits_svc");
+      assert_serialization(GenericDownloadType::RocketVc, "rocket_vc");
+      assert_serialization(GenericDownloadType::RvcV2, "rvc_v2");
+      assert_serialization(GenericDownloadType::SoVitsSvc, "so_vits_svc");
+      assert_serialization(GenericDownloadType::Tacotron2, "tacotron2");
+      assert_serialization(GenericDownloadType::Vits, "vits");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("hifigan", GenericDownloadType::HifiGan);
+      assert_deserialization("hifigan_rocket_vc", GenericDownloadType::HifiGanRocketVc);
+      assert_deserialization("hifigan_so_vits_svc", GenericDownloadType::HifiGanSoVitsSvc);
+      assert_deserialization("rocket_vc", GenericDownloadType::RocketVc);
+      assert_deserialization("rvc_v2", GenericDownloadType::RvcV2);
+      assert_deserialization("so_vits_svc", GenericDownloadType::SoVitsSvc);
+      assert_deserialization("tacotron2", GenericDownloadType::Tacotron2);
+      assert_deserialization("vits", GenericDownloadType::Vits);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(GenericDownloadType::iter().count(), 8);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/frontend_failure_category.rs

@@ -97,11 +97,46 @@ pub enum FrontendFailureCategory {
 #[cfg(test)]
 mod tests {
   use super::FrontendFailureCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(FrontendFailureCategory::FaceNotDetected, "face_not_detected");
+      assert_serialization(FrontendFailureCategory::KeepAliveElapsed, "keep_alive_elapsed");
+      assert_serialization(FrontendFailureCategory::NotYetImplemented, "not_yet_implemented");
+      assert_serialization(FrontendFailureCategory::RetryableWorkerError, "retryable_worker_error");
+      assert_serialization(FrontendFailureCategory::ModelRulesViolation, "model_rules_violation");
+      assert_serialization(FrontendFailureCategory::RuleBansUserImage, "rule_bans_user_image");
+      assert_serialization(FrontendFailureCategory::RuleBansUserImageWithFaces, "rule_bans_user_image_with_faces");
+      assert_serialization(FrontendFailureCategory::RuleBansUserTextPrompt, "rule_bans_user_text_prompt");
+      assert_serialization(FrontendFailureCategory::RuleBansUserContent, "rule_bans_user_content");
+      assert_serialization(FrontendFailureCategory::RuleBansGeneratedVideo, "rule_bans_generated_video");
+      assert_serialization(FrontendFailureCategory::RuleBansGeneratedAudio, "rule_bans_generated_audio");
+      assert_serialization(FrontendFailureCategory::RuleBansGeneratedContent, "rule_bans_generated_content");
+      assert_serialization(FrontendFailureCategory::GenerationFailed, "generation_failed");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("face_not_detected", FrontendFailureCategory::FaceNotDetected);
+      assert_deserialization("keep_alive_elapsed", FrontendFailureCategory::KeepAliveElapsed);
+      assert_deserialization("not_yet_implemented", FrontendFailureCategory::NotYetImplemented);
+      assert_deserialization("retryable_worker_error", FrontendFailureCategory::RetryableWorkerError);
+      assert_deserialization("model_rules_violation", FrontendFailureCategory::ModelRulesViolation);
+      assert_deserialization("rule_bans_user_image", FrontendFailureCategory::RuleBansUserImage);
+      assert_deserialization("rule_bans_user_image_with_faces", FrontendFailureCategory::RuleBansUserImageWithFaces);
+      assert_deserialization("rule_bans_user_text_prompt", FrontendFailureCategory::RuleBansUserTextPrompt);
+      assert_deserialization("rule_bans_user_content", FrontendFailureCategory::RuleBansUserContent);
+      assert_deserialization("rule_bans_generated_video", FrontendFailureCategory::RuleBansGeneratedVideo);
+      assert_deserialization("rule_bans_generated_audio", FrontendFailureCategory::RuleBansGeneratedAudio);
+      assert_deserialization("rule_bans_generated_content", FrontendFailureCategory::RuleBansGeneratedContent);
+      assert_deserialization("generation_failed", FrontendFailureCategory::GenerationFailed);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(FrontendFailureCategory::iter().count(), 13);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_category.rs

@@ -90,11 +90,54 @@ pub enum InferenceCategory {
 #[cfg(test)]
 mod tests {
   use super::InferenceCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(InferenceCategory::DeprecatedField, "deprecated_field");
+      assert_serialization(InferenceCategory::LipsyncAnimation, "lipsync_animation");
+      assert_serialization(InferenceCategory::TextToSpeech, "text_to_speech");
+      assert_serialization(InferenceCategory::VoiceConversion, "voice_conversion");
+      assert_serialization(InferenceCategory::ImageGeneration, "image_generation");
+      assert_serialization(InferenceCategory::VideoGeneration, "video_generation");
+      assert_serialization(InferenceCategory::ObjectGeneration, "object_generation");
+      assert_serialization(InferenceCategory::SplatGeneration, "splat_generation");
+      assert_serialization(InferenceCategory::BackgroundRemoval, "background_removal");
+      assert_serialization(InferenceCategory::Mocap, "mocap");
+      assert_serialization(InferenceCategory::Workflow, "workflow");
+      assert_serialization(InferenceCategory::FormatConversion, "format_conversion");
+      assert_serialization(InferenceCategory::LivePortrait, "live_portrait");
+      assert_serialization(InferenceCategory::SeedVc, "seed_vc");
+      assert_serialization(InferenceCategory::VideoFilter, "video_filter");
+      assert_serialization(InferenceCategory::ConvertBvhToWorkflow, "convert_bvh_to_workflow");
+      assert_serialization(InferenceCategory::F5TTS, "f5_tts");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("deprecated_field", InferenceCategory::DeprecatedField);
+      assert_deserialization("lipsync_animation", InferenceCategory::LipsyncAnimation);
+      assert_deserialization("text_to_speech", InferenceCategory::TextToSpeech);
+      assert_deserialization("voice_conversion", InferenceCategory::VoiceConversion);
+      assert_deserialization("image_generation", InferenceCategory::ImageGeneration);
+      assert_deserialization("video_generation", InferenceCategory::VideoGeneration);
+      assert_deserialization("object_generation", InferenceCategory::ObjectGeneration);
+      assert_deserialization("splat_generation", InferenceCategory::SplatGeneration);
+      assert_deserialization("background_removal", InferenceCategory::BackgroundRemoval);
+      assert_deserialization("mocap", InferenceCategory::Mocap);
+      assert_deserialization("workflow", InferenceCategory::Workflow);
+      assert_deserialization("format_conversion", InferenceCategory::FormatConversion);
+      assert_deserialization("live_portrait", InferenceCategory::LivePortrait);
+      assert_deserialization("seed_vc", InferenceCategory::SeedVc);
+      assert_deserialization("video_filter", InferenceCategory::VideoFilter);
+      assert_deserialization("convert_bvh_to_workflow", InferenceCategory::ConvertBvhToWorkflow);
+      assert_deserialization("f5_tts", InferenceCategory::F5TTS);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(InferenceCategory::iter().count(), 17);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_input_source_token_type.rs

@@ -16,11 +16,24 @@ pub enum InferenceInputSourceTokenType {
 #[cfg(test)]
 mod tests {
   use super::InferenceInputSourceTokenType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(InferenceInputSourceTokenType::MediaFile, "media_file");
+      assert_serialization(InferenceInputSourceTokenType::MediaUpload, "media_upload");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", InferenceInputSourceTokenType::MediaFile);
+      assert_deserialization("media_upload", InferenceInputSourceTokenType::MediaUpload);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(InferenceInputSourceTokenType::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs

@@ -25,11 +25,26 @@ pub enum InferenceJobExternalThirdParty {
 #[cfg(test)]
 mod tests {
   use super::InferenceJobExternalThirdParty;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(InferenceJobExternalThirdParty::Fal, "fal");
+      assert_serialization(InferenceJobExternalThirdParty::Seedance2Pro, "seedance2pro");
+      assert_serialization(InferenceJobExternalThirdParty::Worldlabs, "worldlabs");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("fal", InferenceJobExternalThirdParty::Fal);
+      assert_deserialization("seedance2pro", InferenceJobExternalThirdParty::Seedance2Pro);
+      assert_deserialization("worldlabs", InferenceJobExternalThirdParty::Worldlabs);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(InferenceJobExternalThirdParty::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_job_product_category.rs

@@ -122,11 +122,78 @@ pub enum InferenceJobProductCategory {
 #[cfg(test)]
 mod tests {
   use super::InferenceJobProductCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(InferenceJobProductCategory::DownloadGptSoVits, "download_gpt_so_vits");
+      assert_serialization(InferenceJobProductCategory::FalImage, "fal_image");
+      assert_serialization(InferenceJobProductCategory::FalVideo, "fal_video");
+      assert_serialization(InferenceJobProductCategory::FalObject, "fal_object");
+      assert_serialization(InferenceJobProductCategory::FalBgRemoval, "fal_bg_removal");
+      assert_serialization(InferenceJobProductCategory::Seedance2ProVideo, "seedance2pro_video");
+      assert_serialization(InferenceJobProductCategory::WorldlabsSplat, "worldlabs_splat");
+      assert_serialization(InferenceJobProductCategory::TtsGptSoVits, "tts_gpt_so_vits");
+      assert_serialization(InferenceJobProductCategory::TtsF5, "tts_f5");
+      assert_serialization(InferenceJobProductCategory::TtsStyleTts2, "tts_style_tts2");
+      assert_serialization(InferenceJobProductCategory::TtsTacotron2, "tts_tacotron2");
+      assert_serialization(InferenceJobProductCategory::VcRvc2, "vc_rvc2");
+      assert_serialization(InferenceJobProductCategory::VcSvc, "vc_svc");
+      assert_serialization(InferenceJobProductCategory::VcSeedVc, "vc_seed_vc");
+      assert_serialization(InferenceJobProductCategory::VidLipsyncFaceFusion, "vid_lipsync_face_fusion");
+      assert_serialization(InferenceJobProductCategory::VidLipsyncSadTalker, "vid_lipsync_sad_talker");
+      assert_serialization(InferenceJobProductCategory::VidLivePortrait, "vid_live_portrait");
+      assert_serialization(InferenceJobProductCategory::VidLivePortraitWebcam, "vid_live_portrait_webcam");
+      assert_serialization(InferenceJobProductCategory::VidStudio, "vid_studio");
+      assert_serialization(InferenceJobProductCategory::VidStudioGen2, "vid_studio_gen2");
+      assert_serialization(InferenceJobProductCategory::VidStyleTransfer, "vid_style_transfer");
+      assert_serialization(InferenceJobProductCategory::LipsyncFaceFusion, "lipsync_face_fusion");
+      assert_serialization(InferenceJobProductCategory::LipsyncSadTalker, "lipsync_sad_talker");
+      assert_serialization(InferenceJobProductCategory::LivePortrait, "live_portrait");
+      assert_serialization(InferenceJobProductCategory::LivePortraitWebcam, "live_portrait_webcam");
+      assert_serialization(InferenceJobProductCategory::StableDiffusion, "stable_diffusion");
+      assert_serialization(InferenceJobProductCategory::Studio, "studio");
+      assert_serialization(InferenceJobProductCategory::VidFaceFusion, "vid_face_fusion");
+      assert_serialization(InferenceJobProductCategory::Vst, "vst");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("download_gpt_so_vits", InferenceJobProductCategory::DownloadGptSoVits);
+      assert_deserialization("fal_image", InferenceJobProductCategory::FalImage);
+      assert_deserialization("fal_video", InferenceJobProductCategory::FalVideo);
+      assert_deserialization("fal_object", InferenceJobProductCategory::FalObject);
+      assert_deserialization("fal_bg_removal", InferenceJobProductCategory::FalBgRemoval);
+      assert_deserialization("seedance2pro_video", InferenceJobProductCategory::Seedance2ProVideo);
+      assert_deserialization("worldlabs_splat", InferenceJobProductCategory::WorldlabsSplat);
+      assert_deserialization("tts_gpt_so_vits", InferenceJobProductCategory::TtsGptSoVits);
+      assert_deserialization("tts_f5", InferenceJobProductCategory::TtsF5);
+      assert_deserialization("tts_style_tts2", InferenceJobProductCategory::TtsStyleTts2);
+      assert_deserialization("tts_tacotron2", InferenceJobProductCategory::TtsTacotron2);
+      assert_deserialization("vc_rvc2", InferenceJobProductCategory::VcRvc2);
+      assert_deserialization("vc_svc", InferenceJobProductCategory::VcSvc);
+      assert_deserialization("vc_seed_vc", InferenceJobProductCategory::VcSeedVc);
+      assert_deserialization("vid_lipsync_face_fusion", InferenceJobProductCategory::VidLipsyncFaceFusion);
+      assert_deserialization("vid_lipsync_sad_talker", InferenceJobProductCategory::VidLipsyncSadTalker);
+      assert_deserialization("vid_live_portrait", InferenceJobProductCategory::VidLivePortrait);
+      assert_deserialization("vid_live_portrait_webcam", InferenceJobProductCategory::VidLivePortraitWebcam);
+      assert_deserialization("vid_studio", InferenceJobProductCategory::VidStudio);
+      assert_deserialization("vid_studio_gen2", InferenceJobProductCategory::VidStudioGen2);
+      assert_deserialization("vid_style_transfer", InferenceJobProductCategory::VidStyleTransfer);
+      assert_deserialization("lipsync_face_fusion", InferenceJobProductCategory::LipsyncFaceFusion);
+      assert_deserialization("lipsync_sad_talker", InferenceJobProductCategory::LipsyncSadTalker);
+      assert_deserialization("live_portrait", InferenceJobProductCategory::LivePortrait);
+      assert_deserialization("live_portrait_webcam", InferenceJobProductCategory::LivePortraitWebcam);
+      assert_deserialization("stable_diffusion", InferenceJobProductCategory::StableDiffusion);
+      assert_deserialization("studio", InferenceJobProductCategory::Studio);
+      assert_deserialization("vid_face_fusion", InferenceJobProductCategory::VidFaceFusion);
+      assert_deserialization("vst", InferenceJobProductCategory::Vst);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(InferenceJobProductCategory::iter().count(), 29);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_model_type.rs

@@ -57,11 +57,50 @@ pub enum InferenceModelType {
 #[cfg(test)]
 mod tests {
   use super::InferenceModelType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(InferenceModelType::ComfyUi, "comfy_ui");
+      assert_serialization(InferenceModelType::RvcV2, "rvc_v2");
+      assert_serialization(InferenceModelType::SadTalker, "sad_talker");
+      assert_serialization(InferenceModelType::SoVitsSvc, "so_vits_svc");
+      assert_serialization(InferenceModelType::SeedVc, "seed_vc");
+      assert_serialization(InferenceModelType::ImageGenApi, "image_gen_api");
+      assert_serialization(InferenceModelType::Tacotron2, "tacotron2");
+      assert_serialization(InferenceModelType::Vits, "vits");
+      assert_serialization(InferenceModelType::VallEX, "vall_e_x");
+      assert_serialization(InferenceModelType::RerenderAVideo, "rerender_a_video");
+      assert_serialization(InferenceModelType::StableDiffusion, "stable_diffusion");
+      assert_serialization(InferenceModelType::MocapNet, "mocap_net");
+      assert_serialization(InferenceModelType::StyleTTS2, "styletts2");
+      assert_serialization(InferenceModelType::ConvertFbxToGltf, "convert_fbx_gltf");
+      assert_serialization(InferenceModelType::BvhToWorkflow, "bvh_to_workflow");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("comfy_ui", InferenceModelType::ComfyUi);
+      assert_deserialization("rvc_v2", InferenceModelType::RvcV2);
+      assert_deserialization("sad_talker", InferenceModelType::SadTalker);
+      assert_deserialization("so_vits_svc", InferenceModelType::SoVitsSvc);
+      assert_deserialization("seed_vc", InferenceModelType::SeedVc);
+      assert_deserialization("image_gen_api", InferenceModelType::ImageGenApi);
+      assert_deserialization("tacotron2", InferenceModelType::Tacotron2);
+      assert_deserialization("vits", InferenceModelType::Vits);
+      assert_deserialization("vall_e_x", InferenceModelType::VallEX);
+      assert_deserialization("rerender_a_video", InferenceModelType::RerenderAVideo);
+      assert_deserialization("stable_diffusion", InferenceModelType::StableDiffusion);
+      assert_deserialization("mocap_net", InferenceModelType::MocapNet);
+      assert_deserialization("styletts2", InferenceModelType::StyleTTS2);
+      assert_deserialization("convert_fbx_gltf", InferenceModelType::ConvertFbxToGltf);
+      assert_deserialization("bvh_to_workflow", InferenceModelType::BvhToWorkflow);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(InferenceModelType::iter().count(), 15);

crates/schema/public/enums_api/src/by_table/generic_inference_jobs/inference_result_type.rs

@@ -33,11 +33,30 @@ pub enum InferenceResultType {
 #[cfg(test)]
 mod tests {
   use super::InferenceResultType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(InferenceResultType::MediaFile, "media_file");
+      assert_serialization(InferenceResultType::TextToSpeech, "text_to_speech");
+      assert_serialization(InferenceResultType::VoiceConversion, "voice_conversion");
+      assert_serialization(InferenceResultType::ZeroShotVoiceEmbedding, "zs_voice_embedding");
+      assert_serialization(InferenceResultType::UploadModel, "upload_model");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", InferenceResultType::MediaFile);
+      assert_deserialization("text_to_speech", InferenceResultType::TextToSpeech);
+      assert_deserialization("voice_conversion", InferenceResultType::VoiceConversion);
+      assert_deserialization("zs_voice_embedding", InferenceResultType::ZeroShotVoiceEmbedding);
+      assert_deserialization("upload_model", InferenceResultType::UploadModel);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(InferenceResultType::iter().count(), 5);

crates/schema/public/enums_api/src/by_table/generic_synthetic_ids/id_category.rs

@@ -74,11 +74,50 @@ pub enum IdCategory {
 #[cfg(test)]
 mod tests {
   use super::IdCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(IdCategory::MediaFile, "media_file");
+      assert_serialization(IdCategory::LipsyncAnimationResult, "lipsync_animation");
+      assert_serialization(IdCategory::FaceFusionResult, "face_fusion");
+      assert_serialization(IdCategory::VideoFilterResult, "video_filter");
+      assert_serialization(IdCategory::LivePortraitResult, "live_portrait");
+      assert_serialization(IdCategory::StudioRender, "studio_render");
+      assert_serialization(IdCategory::MocapResult, "mocap");
+      assert_serialization(IdCategory::WorkflowResult, "workflow");
+      assert_serialization(IdCategory::TtsResult, "tts_result");
+      assert_serialization(IdCategory::VoiceConversionResult, "voice_conversion");
+      assert_serialization(IdCategory::ZeroShotTtsResult, "zs_tts_result");
+      assert_serialization(IdCategory::ZeroShotVoiceDataset, "zs_dataset");
+      assert_serialization(IdCategory::ZeroShotVoiceEmbedding, "zs_voice");
+      assert_serialization(IdCategory::ModelWeights, "model_weights");
+      assert_serialization(IdCategory::FileUpload, "file_upload");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", IdCategory::MediaFile);
+      assert_deserialization("lipsync_animation", IdCategory::LipsyncAnimationResult);
+      assert_deserialization("face_fusion", IdCategory::FaceFusionResult);
+      assert_deserialization("video_filter", IdCategory::VideoFilterResult);
+      assert_deserialization("live_portrait", IdCategory::LivePortraitResult);
+      assert_deserialization("studio_render", IdCategory::StudioRender);
+      assert_deserialization("mocap", IdCategory::MocapResult);
+      assert_deserialization("workflow", IdCategory::WorkflowResult);
+      assert_deserialization("tts_result", IdCategory::TtsResult);
+      assert_deserialization("voice_conversion", IdCategory::VoiceConversionResult);
+      assert_deserialization("zs_tts_result", IdCategory::ZeroShotTtsResult);
+      assert_deserialization("zs_dataset", IdCategory::ZeroShotVoiceDataset);
+      assert_deserialization("zs_voice", IdCategory::ZeroShotVoiceEmbedding);
+      assert_deserialization("model_weights", IdCategory::ModelWeights);
+      assert_deserialization("file_upload", IdCategory::FileUpload);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(IdCategory::iter().count(), 15);

crates/schema/public/enums_api/src/by_table/media_files/media_file_animation_type.rs

@@ -64,11 +64,46 @@ pub enum MediaFileAnimationType {
 #[cfg(test)]
 mod tests {
   use super::MediaFileAnimationType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileAnimationType::ArKit, "ar_kit");
+      assert_serialization(MediaFileAnimationType::MikuMikuDance, "miku_miku_dance");
+      assert_serialization(MediaFileAnimationType::MikuMikuDanceArKit, "miku_miku_dance_ar_kit");
+      assert_serialization(MediaFileAnimationType::Mixamo, "mixamo");
+      assert_serialization(MediaFileAnimationType::MixamoArKit, "mixamo_ar_kit");
+      assert_serialization(MediaFileAnimationType::MocapNet, "mocap_net");
+      assert_serialization(MediaFileAnimationType::MocapNetArKit, "mocap_net_ar_kit");
+      assert_serialization(MediaFileAnimationType::MoveAi, "move_ai");
+      assert_serialization(MediaFileAnimationType::MoveAiArKit, "move_ai_ar_kit");
+      assert_serialization(MediaFileAnimationType::Rigify, "rigify");
+      assert_serialization(MediaFileAnimationType::RigifyArKit, "rigify_ar_kit");
+      assert_serialization(MediaFileAnimationType::Rokoko, "rokoko");
+      assert_serialization(MediaFileAnimationType::RokokoArKit, "rokoko_ar_kit");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("ar_kit", MediaFileAnimationType::ArKit);
+      assert_deserialization("miku_miku_dance", MediaFileAnimationType::MikuMikuDance);
+      assert_deserialization("miku_miku_dance_ar_kit", MediaFileAnimationType::MikuMikuDanceArKit);
+      assert_deserialization("mixamo", MediaFileAnimationType::Mixamo);
+      assert_deserialization("mixamo_ar_kit", MediaFileAnimationType::MixamoArKit);
+      assert_deserialization("mocap_net", MediaFileAnimationType::MocapNet);
+      assert_deserialization("mocap_net_ar_kit", MediaFileAnimationType::MocapNetArKit);
+      assert_deserialization("move_ai", MediaFileAnimationType::MoveAi);
+      assert_deserialization("move_ai_ar_kit", MediaFileAnimationType::MoveAiArKit);
+      assert_deserialization("rigify", MediaFileAnimationType::Rigify);
+      assert_deserialization("rigify_ar_kit", MediaFileAnimationType::RigifyArKit);
+      assert_deserialization("rokoko", MediaFileAnimationType::Rokoko);
+      assert_deserialization("rokoko_ar_kit", MediaFileAnimationType::RokokoArKit);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileAnimationType::iter().count(), 13);

crates/schema/public/enums_api/src/by_table/media_files/media_file_class.rs

@@ -28,11 +28,30 @@ pub enum MediaFileClass {
 #[cfg(test)]
 mod tests {
   use super::MediaFileClass;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileClass::Unknown, "unknown");
+      assert_serialization(MediaFileClass::Audio, "audio");
+      assert_serialization(MediaFileClass::Image, "image");
+      assert_serialization(MediaFileClass::Video, "video");
+      assert_serialization(MediaFileClass::Dimensional, "dimensional");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("unknown", MediaFileClass::Unknown);
+      assert_deserialization("audio", MediaFileClass::Audio);
+      assert_deserialization("image", MediaFileClass::Image);
+      assert_deserialization("video", MediaFileClass::Video);
+      assert_deserialization("dimensional", MediaFileClass::Dimensional);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileClass::iter().count(), 5);

crates/schema/public/enums_api/src/by_table/media_files/media_file_engine_category.rs

@@ -52,11 +52,42 @@ pub enum MediaFileEngineCategory {
 #[cfg(test)]
 mod tests {
   use super::MediaFileEngineCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileEngineCategory::Scene, "scene");
+      assert_serialization(MediaFileEngineCategory::Character, "character");
+      assert_serialization(MediaFileEngineCategory::Creature, "creature");
+      assert_serialization(MediaFileEngineCategory::Animation, "animation");
+      assert_serialization(MediaFileEngineCategory::Expression, "expression");
+      assert_serialization(MediaFileEngineCategory::Location, "location");
+      assert_serialization(MediaFileEngineCategory::SetDressing, "set_dressing");
+      assert_serialization(MediaFileEngineCategory::Object, "object");
+      assert_serialization(MediaFileEngineCategory::Skybox, "skybox");
+      assert_serialization(MediaFileEngineCategory::ImagePlane, "image_plane");
+      assert_serialization(MediaFileEngineCategory::VideoPlane, "video_plane");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("scene", MediaFileEngineCategory::Scene);
+      assert_deserialization("character", MediaFileEngineCategory::Character);
+      assert_deserialization("creature", MediaFileEngineCategory::Creature);
+      assert_deserialization("animation", MediaFileEngineCategory::Animation);
+      assert_deserialization("expression", MediaFileEngineCategory::Expression);
+      assert_deserialization("location", MediaFileEngineCategory::Location);
+      assert_deserialization("set_dressing", MediaFileEngineCategory::SetDressing);
+      assert_deserialization("object", MediaFileEngineCategory::Object);
+      assert_deserialization("skybox", MediaFileEngineCategory::Skybox);
+      assert_deserialization("image_plane", MediaFileEngineCategory::ImagePlane);
+      assert_deserialization("video_plane", MediaFileEngineCategory::VideoPlane);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileEngineCategory::iter().count(), 11);

crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_category.rs

@@ -33,11 +33,32 @@ pub enum MediaFileOriginCategory {
 #[cfg(test)]
 mod tests {
   use super::MediaFileOriginCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileOriginCategory::Inference, "inference");
+      assert_serialization(MediaFileOriginCategory::Processed, "processed");
+      assert_serialization(MediaFileOriginCategory::Upload, "upload");
+      assert_serialization(MediaFileOriginCategory::DeviceApi, "device_api");
+      assert_serialization(MediaFileOriginCategory::StorytellerStudio, "studio");
+      assert_serialization(MediaFileOriginCategory::StoryEngine, "story_engine");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("inference", MediaFileOriginCategory::Inference);
+      assert_deserialization("processed", MediaFileOriginCategory::Processed);
+      assert_deserialization("upload", MediaFileOriginCategory::Upload);
+      assert_deserialization("device_api", MediaFileOriginCategory::DeviceApi);
+      assert_deserialization("studio", MediaFileOriginCategory::StorytellerStudio);
+      assert_deserialization("story_engine", MediaFileOriginCategory::StoryEngine);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileOriginCategory::iter().count(), 6);

crates/schema/public/enums_api/src/by_table/media_files/media_file_origin_product_category.rs

@@ -81,11 +81,52 @@ pub enum MediaFileOriginProductCategory {
 #[cfg(test)]
 mod tests {
   use super::MediaFileOriginProductCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileOriginProductCategory::Unknown, "unknown");
+      assert_serialization(MediaFileOriginProductCategory::FaceAnimator, "face_animator");
+      assert_serialization(MediaFileOriginProductCategory::FaceFusion, "face_fusion");
+      assert_serialization(MediaFileOriginProductCategory::FaceMirror, "face_mirror");
+      assert_serialization(MediaFileOriginProductCategory::VideoStyleTransfer, "vst");
+      assert_serialization(MediaFileOriginProductCategory::ImageStudio, "image_studio");
+      assert_serialization(MediaFileOriginProductCategory::StorytellerStudio, "studio");
+      assert_serialization(MediaFileOriginProductCategory::TextToSpeech, "tts");
+      assert_serialization(MediaFileOriginProductCategory::VoiceConversion, "voice_conversion");
+      assert_serialization(MediaFileOriginProductCategory::ZeroShotVoice, "zs_voice");
+      assert_serialization(MediaFileOriginProductCategory::Mocap, "mocap");
+      assert_serialization(MediaFileOriginProductCategory::ImageGeneration, "image_gen");
+      assert_serialization(MediaFileOriginProductCategory::VideoGeneration, "video_gen");
+      assert_serialization(MediaFileOriginProductCategory::WorldGeneration, "world_gen");
+      assert_serialization(MediaFileOriginProductCategory::VideoFilter, "video_filter");
+      assert_serialization(MediaFileOriginProductCategory::Workflow, "workflow");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("unknown", MediaFileOriginProductCategory::Unknown);
+      assert_deserialization("face_animator", MediaFileOriginProductCategory::FaceAnimator);
+      assert_deserialization("face_fusion", MediaFileOriginProductCategory::FaceFusion);
+      assert_deserialization("face_mirror", MediaFileOriginProductCategory::FaceMirror);
+      assert_deserialization("vst", MediaFileOriginProductCategory::VideoStyleTransfer);
+      assert_deserialization("image_studio", MediaFileOriginProductCategory::ImageStudio);
+      assert_deserialization("studio", MediaFileOriginProductCategory::StorytellerStudio);
+      assert_deserialization("tts", MediaFileOriginProductCategory::TextToSpeech);
+      assert_deserialization("voice_conversion", MediaFileOriginProductCategory::VoiceConversion);
+      assert_deserialization("zs_voice", MediaFileOriginProductCategory::ZeroShotVoice);
+      assert_deserialization("mocap", MediaFileOriginProductCategory::Mocap);
+      assert_deserialization("image_gen", MediaFileOriginProductCategory::ImageGeneration);
+      assert_deserialization("video_gen", MediaFileOriginProductCategory::VideoGeneration);
+      assert_deserialization("world_gen", MediaFileOriginProductCategory::WorldGeneration);
+      assert_deserialization("video_filter", MediaFileOriginProductCategory::VideoFilter);
+      assert_deserialization("workflow", MediaFileOriginProductCategory::Workflow);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileOriginProductCategory::iter().count(), 16);

crates/schema/public/enums_api/src/by_table/media_files/media_file_subtype.rs

@@ -57,11 +57,42 @@ pub enum MediaFileSubtype {
 #[cfg(test)]
 mod tests {
   use super::MediaFileSubtype;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileSubtype::Deprecated, "deprecated");
+      assert_serialization(MediaFileSubtype::Mixamo, "mixamo");
+      assert_serialization(MediaFileSubtype::MocapNet, "mocap_net");
+      assert_serialization(MediaFileSubtype::AnimationOnly, "animation_only");
+      assert_serialization(MediaFileSubtype::SceneImport, "scene_import");
+      assert_serialization(MediaFileSubtype::StorytellerScene, "storyteller_scene");
+      assert_serialization(MediaFileSubtype::Scene, "scene");
+      assert_serialization(MediaFileSubtype::Character, "character");
+      assert_serialization(MediaFileSubtype::Animation, "animation");
+      assert_serialization(MediaFileSubtype::Object, "object");
+      assert_serialization(MediaFileSubtype::Skybox, "skybox");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("deprecated", MediaFileSubtype::Deprecated);
+      assert_deserialization("mixamo", MediaFileSubtype::Mixamo);
+      assert_deserialization("mocap_net", MediaFileSubtype::MocapNet);
+      assert_deserialization("animation_only", MediaFileSubtype::AnimationOnly);
+      assert_deserialization("scene_import", MediaFileSubtype::SceneImport);
+      assert_deserialization("storyteller_scene", MediaFileSubtype::StorytellerScene);
+      assert_deserialization("scene", MediaFileSubtype::Scene);
+      assert_deserialization("character", MediaFileSubtype::Character);
+      assert_deserialization("animation", MediaFileSubtype::Animation);
+      assert_deserialization("object", MediaFileSubtype::Object);
+      assert_deserialization("skybox", MediaFileSubtype::Skybox);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileSubtype::iter().count(), 11);

crates/schema/public/enums_api/src/by_table/media_files/media_file_type.rs

@@ -87,11 +87,60 @@ pub enum MediaFileType {
 #[cfg(test)]
 mod tests {
   use super::MediaFileType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaFileType::Audio, "audio");
+      assert_serialization(MediaFileType::Image, "image");
+      assert_serialization(MediaFileType::Video, "video");
+      assert_serialization(MediaFileType::Bvh, "bvh");
+      assert_serialization(MediaFileType::Fbx, "fbx");
+      assert_serialization(MediaFileType::Glb, "glb");
+      assert_serialization(MediaFileType::Gltf, "gltf");
+      assert_serialization(MediaFileType::Spz, "spz");
+      assert_serialization(MediaFileType::SceneRon, "scene_ron");
+      assert_serialization(MediaFileType::SceneJson, "scene_json");
+      assert_serialization(MediaFileType::Pmd, "pmd");
+      assert_serialization(MediaFileType::Vmd, "vmd");
+      assert_serialization(MediaFileType::Pmx, "pmx");
+      assert_serialization(MediaFileType::Csv, "csv");
+      assert_serialization(MediaFileType::Jpg, "jpg");
+      assert_serialization(MediaFileType::Png, "png");
+      assert_serialization(MediaFileType::Gif, "gif");
+      assert_serialization(MediaFileType::Mp4, "mp4");
+      assert_serialization(MediaFileType::Wav, "wav");
+      assert_serialization(MediaFileType::Mp3, "mp3");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("audio", MediaFileType::Audio);
+      assert_deserialization("image", MediaFileType::Image);
+      assert_deserialization("video", MediaFileType::Video);
+      assert_deserialization("bvh", MediaFileType::Bvh);
+      assert_deserialization("fbx", MediaFileType::Fbx);
+      assert_deserialization("glb", MediaFileType::Glb);
+      assert_deserialization("gltf", MediaFileType::Gltf);
+      assert_deserialization("spz", MediaFileType::Spz);
+      assert_deserialization("scene_ron", MediaFileType::SceneRon);
+      assert_deserialization("scene_json", MediaFileType::SceneJson);
+      assert_deserialization("pmd", MediaFileType::Pmd);
+      assert_deserialization("vmd", MediaFileType::Vmd);
+      assert_deserialization("pmx", MediaFileType::Pmx);
+      assert_deserialization("csv", MediaFileType::Csv);
+      assert_deserialization("jpg", MediaFileType::Jpg);
+      assert_deserialization("png", MediaFileType::Png);
+      assert_deserialization("gif", MediaFileType::Gif);
+      assert_deserialization("mp4", MediaFileType::Mp4);
+      assert_deserialization("wav", MediaFileType::Wav);
+      assert_deserialization("mp3", MediaFileType::Mp3);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaFileType::iter().count(), 20);

crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_source.rs

@@ -23,11 +23,26 @@ pub enum MediaUploadSource {
 #[cfg(test)]
 mod tests {
   use super::MediaUploadSource;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaUploadSource::DeviceApi, "device_api");
+      assert_serialization(MediaUploadSource::File, "file");
+      assert_serialization(MediaUploadSource::Unknown, "unknown");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("device_api", MediaUploadSource::DeviceApi);
+      assert_deserialization("file", MediaUploadSource::File);
+      assert_deserialization("unknown", MediaUploadSource::Unknown);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaUploadSource::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/media_uploads/media_upload_type.rs

@@ -24,11 +24,28 @@ pub enum MediaUploadType {
 #[cfg(test)]
 mod tests {
   use super::MediaUploadType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(MediaUploadType::Audio, "audio");
+      assert_serialization(MediaUploadType::Image, "image");
+      assert_serialization(MediaUploadType::Video, "video");
+      assert_serialization(MediaUploadType::Binary, "binary");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("audio", MediaUploadType::Audio);
+      assert_deserialization("image", MediaUploadType::Image);
+      assert_deserialization("video", MediaUploadType::Video);
+      assert_deserialization("binary", MediaUploadType::Binary);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(MediaUploadType::iter().count(), 4);

crates/schema/public/enums_api/src/by_table/model_categories/model_type.rs

@@ -16,11 +16,24 @@ pub enum ModelType {
 #[cfg(test)]
 mod tests {
   use super::ModelType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(ModelType::Tts, "tts");
+      assert_serialization(ModelType::W2l, "w2l");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("tts", ModelType::Tts);
+      assert_deserialization("w2l", ModelType::W2l);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(ModelType::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/model_weights/weights_category.rs

@@ -19,11 +19,30 @@ pub enum WeightsCategory {
 #[cfg(test)]
 mod tests {
   use super::WeightsCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(WeightsCategory::ImageGeneration, "image_generation");
+      assert_serialization(WeightsCategory::TextToSpeech, "text_to_speech");
+      assert_serialization(WeightsCategory::Vocoder, "vocoder");
+      assert_serialization(WeightsCategory::VoiceConversion, "voice_conversion");
+      assert_serialization(WeightsCategory::WorkflowConfig, "workflow_config");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("image_generation", WeightsCategory::ImageGeneration);
+      assert_deserialization("text_to_speech", WeightsCategory::TextToSpeech);
+      assert_deserialization("vocoder", WeightsCategory::Vocoder);
+      assert_deserialization("voice_conversion", WeightsCategory::VoiceConversion);
+      assert_deserialization("workflow_config", WeightsCategory::WorkflowConfig);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(WeightsCategory::iter().count(), 5);

crates/schema/public/enums_api/src/by_table/model_weights/weights_file_type.rs

@@ -14,11 +14,24 @@ pub enum WeightsFileType {
 #[cfg(test)]
 mod tests {
   use super::WeightsFileType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(WeightsFileType::Checkpoint, "checkpoint");
+      assert_serialization(WeightsFileType::SafeTensors, "safetensors");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("checkpoint", WeightsFileType::Checkpoint);
+      assert_deserialization("safetensors", WeightsFileType::SafeTensors);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(WeightsFileType::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/prompt_context_items/prompt_context_semantic_type.rs

@@ -47,11 +47,40 @@ pub enum PromptContextSemanticType {
 #[cfg(test)]
 mod tests {
   use super::PromptContextSemanticType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(PromptContextSemanticType::VidStartFrame, "vid_start_frame");
+      assert_serialization(PromptContextSemanticType::VidEndFrame, "vid_end_frame");
+      assert_serialization(PromptContextSemanticType::VidRef, "vid_ref");
+      assert_serialization(PromptContextSemanticType::Imgsrc, "imgsrc");
+      assert_serialization(PromptContextSemanticType::Imgmask, "imgmask");
+      assert_serialization(PromptContextSemanticType::Imgref, "imgref");
+      assert_serialization(PromptContextSemanticType::ImgrefCharacter, "imgref_character");
+      assert_serialization(PromptContextSemanticType::ImgrefStyle, "imgref_style");
+      assert_serialization(PromptContextSemanticType::ImgrefBg, "imgref_bg");
+      assert_serialization(PromptContextSemanticType::Audioref, "audioref");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("vid_start_frame", PromptContextSemanticType::VidStartFrame);
+      assert_deserialization("vid_end_frame", PromptContextSemanticType::VidEndFrame);
+      assert_deserialization("vid_ref", PromptContextSemanticType::VidRef);
+      assert_deserialization("imgsrc", PromptContextSemanticType::Imgsrc);
+      assert_deserialization("imgmask", PromptContextSemanticType::Imgmask);
+      assert_deserialization("imgref", PromptContextSemanticType::Imgref);
+      assert_deserialization("imgref_character", PromptContextSemanticType::ImgrefCharacter);
+      assert_deserialization("imgref_style", PromptContextSemanticType::ImgrefStyle);
+      assert_deserialization("imgref_bg", PromptContextSemanticType::ImgrefBg);
+      assert_deserialization("audioref", PromptContextSemanticType::Audioref);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(PromptContextSemanticType::iter().count(), 10);

crates/schema/public/enums_api/src/by_table/prompts/prompt_type.rs

@@ -23,11 +23,26 @@ pub enum PromptType {
 #[cfg(test)]
 mod tests {
   use super::PromptType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(PromptType::ArtcraftApp, "artcraft_app");
+      assert_serialization(PromptType::StableDiffusion, "stable_diffusion");
+      assert_serialization(PromptType::ComfyUi, "comfy_ui");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("artcraft_app", PromptType::ArtcraftApp);
+      assert_deserialization("stable_diffusion", PromptType::StableDiffusion);
+      assert_deserialization("comfy_ui", PromptType::ComfyUi);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(PromptType::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/tag_uses/tag_use_entity_type.rs

@@ -17,11 +17,24 @@ pub enum TagUseEntityType {
 #[cfg(test)]
 mod tests {
   use super::TagUseEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(TagUseEntityType::MediaFile, "media_file");
+      assert_serialization(TagUseEntityType::ModelWeight, "model_weight");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", TagUseEntityType::MediaFile);
+      assert_deserialization("model_weight", TagUseEntityType::ModelWeight);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(TagUseEntityType::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/trending_model_analytics/model_type.rs

@@ -18,11 +18,22 @@ pub enum ModelType {
 #[cfg(test)]
 mod tests {
   use super::ModelType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(ModelType::Tts, "tts");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("tts", ModelType::Tts);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(ModelType::iter().count(), 1);

crates/schema/public/enums_api/src/by_table/trending_model_analytics/window_name.rs

@@ -25,11 +25,26 @@ pub enum WindowName {
 #[cfg(test)]
 mod tests {
   use super::WindowName;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(WindowName::Last3Hours, "last_3_hours");
+      assert_serialization(WindowName::Last3Days, "last_3_days");
+      assert_serialization(WindowName::AllTime, "all_time");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("last_3_hours", WindowName::Last3Hours);
+      assert_deserialization("last_3_days", WindowName::Last3Days);
+      assert_deserialization("all_time", WindowName::AllTime);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(WindowName::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/tts_models/tts_model_type.rs

@@ -18,11 +18,24 @@ pub enum TtsModelType {
 #[cfg(test)]
 mod tests {
   use super::TtsModelType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(TtsModelType::Tacotron2, "tacotron2");
+      assert_serialization(TtsModelType::Vits, "vits");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("tacotron2", TtsModelType::Tacotron2);
+      assert_deserialization("vits", TtsModelType::Vits);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(TtsModelType::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/tts_render_tasks/tts_render_status.rs

@@ -28,11 +28,32 @@ pub enum TtsRenderStatus {
 #[cfg(test)]
 mod tests {
   use super::TtsRenderStatus;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(TtsRenderStatus::New, "new");
+      assert_serialization(TtsRenderStatus::Processing, "processing");
+      assert_serialization(TtsRenderStatus::Skipped, "skipped");
+      assert_serialization(TtsRenderStatus::Failed, "failed");
+      assert_serialization(TtsRenderStatus::PermanentlyFailed, "permanently_failed");
+      assert_serialization(TtsRenderStatus::Success, "success");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("new", TtsRenderStatus::New);
+      assert_deserialization("processing", TtsRenderStatus::Processing);
+      assert_deserialization("skipped", TtsRenderStatus::Skipped);
+      assert_deserialization("failed", TtsRenderStatus::Failed);
+      assert_deserialization("permanently_failed", TtsRenderStatus::PermanentlyFailed);
+      assert_deserialization("success", TtsRenderStatus::Success);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(TtsRenderStatus::iter().count(), 6);

crates/schema/public/enums_api/src/by_table/usages/usages_type.rs

@@ -18,11 +18,24 @@ pub enum UsagesType {
 #[cfg(test)]
 mod tests {
   use super::UsagesType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UsagesType::ModelWeight, "model_weight");
+      assert_serialization(UsagesType::MediaFile, "media_file");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("model_weight", UsagesType::ModelWeight);
+      assert_deserialization("media_file", UsagesType::MediaFile);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UsagesType::iter().count(), 2);

crates/schema/public/enums_api/src/by_table/user_bookmarks/user_bookmark_entity_type.rs

@@ -45,11 +45,38 @@ pub enum UserBookmarkEntityType {
 #[cfg(test)]
 mod tests {
   use super::UserBookmarkEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UserBookmarkEntityType::User, "user");
+      assert_serialization(UserBookmarkEntityType::TtsModel, "tts_model");
+      assert_serialization(UserBookmarkEntityType::TtsResult, "tts_result");
+      assert_serialization(UserBookmarkEntityType::W2lTemplate, "w2l_template");
+      assert_serialization(UserBookmarkEntityType::W2lResult, "w2l_result");
+      assert_serialization(UserBookmarkEntityType::MediaFile, "media_file");
+      assert_serialization(UserBookmarkEntityType::ModelWeight, "model_weight");
+      assert_serialization(UserBookmarkEntityType::VoiceConversionModel, "voice_conversion_model");
+      assert_serialization(UserBookmarkEntityType::ZsVoice, "zs_voice");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("user", UserBookmarkEntityType::User);
+      assert_deserialization("tts_model", UserBookmarkEntityType::TtsModel);
+      assert_deserialization("tts_result", UserBookmarkEntityType::TtsResult);
+      assert_deserialization("w2l_template", UserBookmarkEntityType::W2lTemplate);
+      assert_deserialization("w2l_result", UserBookmarkEntityType::W2lResult);
+      assert_deserialization("media_file", UserBookmarkEntityType::MediaFile);
+      assert_deserialization("model_weight", UserBookmarkEntityType::ModelWeight);
+      assert_deserialization("voice_conversion_model", UserBookmarkEntityType::VoiceConversionModel);
+      assert_deserialization("zs_voice", UserBookmarkEntityType::ZsVoice);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UserBookmarkEntityType::iter().count(), 9);

crates/schema/public/enums_api/src/by_table/user_ratings/entity_type.rs

@@ -33,11 +33,32 @@ pub enum UserRatingEntityType {
 #[cfg(test)]
 mod tests {
   use super::UserRatingEntityType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UserRatingEntityType::MediaFile, "media_file");
+      assert_serialization(UserRatingEntityType::ModelWeight, "model_weight");
+      assert_serialization(UserRatingEntityType::TtsModel, "tts_model");
+      assert_serialization(UserRatingEntityType::TtsResult, "tts_result");
+      assert_serialization(UserRatingEntityType::W2lTemplate, "w2l_template");
+      assert_serialization(UserRatingEntityType::W2lResult, "w2l_result");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_file", UserRatingEntityType::MediaFile);
+      assert_deserialization("model_weight", UserRatingEntityType::ModelWeight);
+      assert_deserialization("tts_model", UserRatingEntityType::TtsModel);
+      assert_deserialization("tts_result", UserRatingEntityType::TtsResult);
+      assert_deserialization("w2l_template", UserRatingEntityType::W2lTemplate);
+      assert_deserialization("w2l_result", UserRatingEntityType::W2lResult);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UserRatingEntityType::iter().count(), 6);

crates/schema/public/enums_api/src/by_table/user_ratings/rating_value.rs

@@ -33,11 +33,26 @@ pub enum UserRatingValue {
 #[cfg(test)]
 mod tests {
   use super::UserRatingValue;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UserRatingValue::Neutral, "neutral");
+      assert_serialization(UserRatingValue::Positive, "positive");
+      assert_serialization(UserRatingValue::Negative, "negative");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("neutral", UserRatingValue::Neutral);
+      assert_deserialization("positive", UserRatingValue::Positive);
+      assert_deserialization("negative", UserRatingValue::Negative);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UserRatingValue::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/users/user_feature_flag.rs

@@ -26,11 +26,28 @@ pub enum UserFeatureFlag {
 #[cfg(test)]
 mod tests {
   use super::UserFeatureFlag;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UserFeatureFlag::ExploreMedia, "explore_media");
+      assert_serialization(UserFeatureFlag::Studio, "studio");
+      assert_serialization(UserFeatureFlag::Upload3d, "upload_3d");
+      assert_serialization(UserFeatureFlag::VideoStyleTransfer, "video_style_transfer");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("explore_media", UserFeatureFlag::ExploreMedia);
+      assert_deserialization("studio", UserFeatureFlag::Studio);
+      assert_deserialization("upload_3d", UserFeatureFlag::Upload3d);
+      assert_deserialization("video_style_transfer", UserFeatureFlag::VideoStyleTransfer);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UserFeatureFlag::iter().count(), 4);

crates/schema/public/enums_api/src/by_table/users/user_signup_method.rs

@@ -23,11 +23,26 @@ pub enum UserSignupMethod {
 #[cfg(test)]
 mod tests {
   use super::UserSignupMethod;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UserSignupMethod::EmailPassword, "email_password");
+      assert_serialization(UserSignupMethod::GoogleSignIn, "google_sign_in");
+      assert_serialization(UserSignupMethod::StripeCheckout, "stripe_checkout");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("email_password", UserSignupMethod::EmailPassword);
+      assert_deserialization("google_sign_in", UserSignupMethod::GoogleSignIn);
+      assert_deserialization("stripe_checkout", UserSignupMethod::StripeCheckout);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UserSignupMethod::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/users/user_signup_source.rs

@@ -42,11 +42,36 @@ pub enum UserSignupSource {
 #[cfg(test)]
 mod tests {
   use super::UserSignupSource;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(UserSignupSource::ArtCraft, "artcraft");
+      assert_serialization(UserSignupSource::ArtCraftApp, "artcraft_app");
+      assert_serialization(UserSignupSource::ArtCraftAiWeb, "artcraft_ai_web");
+      assert_serialization(UserSignupSource::ArtCraftAiStripe, "artcraft_ai_s");
+      assert_serialization(UserSignupSource::ArtCraftGetWeb, "artcraft_get_web");
+      assert_serialization(UserSignupSource::ArtCraftGetStripe, "artcraft_get_s");
+      assert_serialization(UserSignupSource::FakeYou, "fakeyou");
+      assert_serialization(UserSignupSource::Storyteller, "storyteller");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("artcraft", UserSignupSource::ArtCraft);
+      assert_deserialization("artcraft_app", UserSignupSource::ArtCraftApp);
+      assert_deserialization("artcraft_ai_web", UserSignupSource::ArtCraftAiWeb);
+      assert_deserialization("artcraft_ai_s", UserSignupSource::ArtCraftAiStripe);
+      assert_deserialization("artcraft_get_web", UserSignupSource::ArtCraftGetWeb);
+      assert_deserialization("artcraft_get_s", UserSignupSource::ArtCraftGetStripe);
+      assert_deserialization("fakeyou", UserSignupSource::FakeYou);
+      assert_deserialization("storyteller", UserSignupSource::Storyteller);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(UserSignupSource::iter().count(), 8);

crates/schema/public/enums_api/src/by_table/voice_conversion_models/voice_conversion_model_type.rs

@@ -22,11 +22,26 @@ pub enum VoiceConversionModelType {
 #[cfg(test)]
 mod tests {
   use super::VoiceConversionModelType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(VoiceConversionModelType::RvcV2, "rvc_v2");
+      assert_serialization(VoiceConversionModelType::SoftVc, "soft_vc");
+      assert_serialization(VoiceConversionModelType::SoVitsSvc, "so_vits_svc");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("rvc_v2", VoiceConversionModelType::RvcV2);
+      assert_deserialization("soft_vc", VoiceConversionModelType::SoftVc);
+      assert_deserialization("so_vits_svc", VoiceConversionModelType::SoVitsSvc);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(VoiceConversionModelType::iter().count(), 3);

crates/schema/public/enums_api/src/by_table/voice_conversion_results/voice_conversion_media_token_type.rs

@@ -15,11 +15,22 @@ pub enum VoiceConversionMediaTokenType {
 #[cfg(test)]
 mod tests {
   use super::VoiceConversionMediaTokenType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(VoiceConversionMediaTokenType::MediaUpload, "media_upload");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("media_upload", VoiceConversionMediaTokenType::MediaUpload);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(VoiceConversionMediaTokenType::iter().count(), 1);

crates/schema/public/enums_api/src/by_table/wallet_ledger_entries/wallet_ledger_entry_type.rs

@@ -52,11 +52,36 @@ pub enum WalletLedgerEntryType {
 #[cfg(test)]
 mod tests {
   use super::WalletLedgerEntryType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(WalletLedgerEntryType::Create, "create");
+      assert_serialization(WalletLedgerEntryType::CreditBanked, "credit_banked");
+      assert_serialization(WalletLedgerEntryType::CreditMonthly, "credit_monthly");
+      assert_serialization(WalletLedgerEntryType::DeductMixed, "deduct_mixed");
+      assert_serialization(WalletLedgerEntryType::DeductBanked, "deduct_banked");
+      assert_serialization(WalletLedgerEntryType::DeductMonthly, "deduct_monthly");
+      assert_serialization(WalletLedgerEntryType::RefundBanked, "refund_banked");
+      assert_serialization(WalletLedgerEntryType::StaffAddBanked, "staff_add_banked");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("create", WalletLedgerEntryType::Create);
+      assert_deserialization("credit_banked", WalletLedgerEntryType::CreditBanked);
+      assert_deserialization("credit_monthly", WalletLedgerEntryType::CreditMonthly);
+      assert_deserialization("deduct_mixed", WalletLedgerEntryType::DeductMixed);
+      assert_deserialization("deduct_banked", WalletLedgerEntryType::DeductBanked);
+      assert_deserialization("deduct_monthly", WalletLedgerEntryType::DeductMonthly);
+      assert_deserialization("refund_banked", WalletLedgerEntryType::RefundBanked);
+      assert_deserialization("staff_add_banked", WalletLedgerEntryType::StaffAddBanked);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(WalletLedgerEntryType::iter().count(), 8);

crates/schema/public/enums_api/src/by_table/web_rendition_targets/rendition_status.rs

@@ -24,11 +24,30 @@ pub enum RenditionStatus {
 #[cfg(test)]
 mod tests {
   use super::RenditionStatus;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(RenditionStatus::New, "new");
+      assert_serialization(RenditionStatus::Skipped, "skipped");
+      assert_serialization(RenditionStatus::Failed, "failed");
+      assert_serialization(RenditionStatus::PermanentlyFailed, "permanently_failed");
+      assert_serialization(RenditionStatus::Success, "success");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("new", RenditionStatus::New);
+      assert_deserialization("skipped", RenditionStatus::Skipped);
+      assert_deserialization("failed", RenditionStatus::Failed);
+      assert_deserialization("permanently_failed", RenditionStatus::PermanentlyFailed);
+      assert_deserialization("success", RenditionStatus::Success);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(RenditionStatus::iter().count(), 5);

crates/schema/public/enums_api/src/by_table/web_scraping_targets/scraping_status.rs

@@ -24,11 +24,30 @@ pub enum ScrapingStatus {
 #[cfg(test)]
 mod tests {
   use super::ScrapingStatus;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(ScrapingStatus::New, "new");
+      assert_serialization(ScrapingStatus::Skipped, "skipped");
+      assert_serialization(ScrapingStatus::Failed, "failed");
+      assert_serialization(ScrapingStatus::PermanentlyFailed, "permanently_failed");
+      assert_serialization(ScrapingStatus::Success, "success");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("new", ScrapingStatus::New);
+      assert_deserialization("skipped", ScrapingStatus::Skipped);
+      assert_deserialization("failed", ScrapingStatus::Failed);
+      assert_deserialization("permanently_failed", ScrapingStatus::PermanentlyFailed);
+      assert_deserialization("success", ScrapingStatus::Success);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(ScrapingStatus::iter().count(), 5);

crates/schema/public/enums_api/src/by_table/zs_voices/encoding_type.rs

@@ -17,11 +17,22 @@ pub enum ZsVoiceEncodingType {
 #[cfg(test)]
 mod tests {
   use super::ZsVoiceEncodingType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(ZsVoiceEncodingType::Encodec, "encodec");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("encodec", ZsVoiceEncodingType::Encodec);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(ZsVoiceEncodingType::iter().count(), 1);

crates/schema/public/enums_api/src/by_table/zs_voices/model_category.rs

@@ -17,11 +17,22 @@ pub enum ZsVoiceModelCategory {
 #[cfg(test)]
 mod tests {
   use super::ZsVoiceModelCategory;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(ZsVoiceModelCategory::Tts, "tts");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("tts", ZsVoiceModelCategory::Tts);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(ZsVoiceModelCategory::iter().count(), 1);

crates/schema/public/enums_api/src/by_table/zs_voices/model_type.rs

@@ -19,11 +19,24 @@ pub enum ZsVoiceModelType {
 #[cfg(test)]
 mod tests {
   use super::ZsVoiceModelType;
+  use enums_shared::test_helpers::{assert_deserialization, assert_serialization};
   use strum::IntoEnumIterator;
 
   mod manual_checks {
     use super::*;
 
+    #[test]
+    fn test_serialization() {
+      assert_serialization(ZsVoiceModelType::VallEX, "vall-e-x");
+      assert_serialization(ZsVoiceModelType::StyleTTS2, "styletts2");
+    }
+
+    #[test]
+    fn test_deserialization() {
+      assert_deserialization("vall-e-x", ZsVoiceModelType::VallEX);
+      assert_deserialization("styletts2", ZsVoiceModelType::StyleTTS2);
+    }
+
     #[test]
     fn variants_count_check() {
       assert_eq!(ZsVoiceModelType::iter().count(), 2);